diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index cc566c54b..4fda2998e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -197,11 +197,11 @@ jobs: cargo test --release -p akita-config --features all-schedules setup_prefix_slots::tests - name: Dense multi-chunk PCS e2e run: | - cargo test --release -p akita-pcs --no-default-features --features parallel,schedules-fp128-d64-dense-multi-chunk chunked_multi_chunk_prove_verify + cargo test --release -p akita-pcs --no-default-features --features parallel,schedules-fp128-dense-multi-chunk chunked_multi_chunk_prove_verify - name: Schedule catalog wiring run: | cargo test --release -p akita-config --no-default-features --test schedule_catalog_feature_off - cargo test --release -p akita-config --features schedules-fp128-d64-onehot,schedules-fp128-d64-dense --test schedule_catalog_miswire + cargo test --release -p akita-config --features schedules-fp128-onehot,schedules-fp128-dense --test schedule_catalog_miswire test-timing: name: Test timing diff --git a/.github/workflows/profile-bench.yml b/.github/workflows/profile-bench.yml index 424378274..a7621e827 100644 --- a/.github/workflows/profile-bench.yml +++ b/.github/workflows/profile-bench.yml @@ -24,12 +24,9 @@ env: # - Small prime fields (fp32/fp64): their D32/D64 schedules are non-securable # under the reprice (they degrade to a cleartext root-direct proof), so the # smallest secure ring degree is D128. Those cells use D128 one-hot. - # - fp128: D64 is the actual proof-size optimum for both dense and one-hot - # (~20% smaller than D128 while still folding through 8-9 secure levels; - # confirmed by `current_d64_onehot_schedule_stays_within_audited_sis_widths` - # and the `best_dense_schedule`/`best_onehot_schedule` selectors, which pick - # D64 over D128). The fp128 cells therefore track D64, not D128. - AKITA_BENCH_MODE: onehot_fp128_d64 + # - fp128: `onehot_fp128` is the canonical direct one-hot profile. Recursive + # and distributed profiles use the corresponding adaptive catalogs. + AKITA_BENCH_MODE: onehot_fp128 AKITA_BENCH_RUNS: "3" # One warm-up run per case is discarded before the measured runs to # prime caches and lazily-initialized statics; cache misses on the @@ -64,32 +61,29 @@ jobs: # is the largest validated size that both fits that budget and still folds # through multiple recursive levels. The fp128 cells fold aggressively enough # to stay at nv=32. - # group: - name: 1-fp128-dense cases: | - dense_fp128_d64:24:1 + dense_fp128:24:1 - name: 3-flat-onehot-suite cases: | onehot_fp32_d128:28:1 onehot_fp64_d128:28:1 - onehot_fp128_d64:32:1 - onehot_fp128_mixed_dim:32:1 - onehot_fp128_d64:30:4 - - name: 4-multi-group-recursive-direct + onehot_fp128:32:1 + - name: 4-multi-group-direct cases: | - onehot_fp128_d64_multi_group_recursive:32:4:direct + onehot_fp128_multi_group:32:4:direct - name: 5-multi-group-recursive cases: | - onehot_fp128_d64_multi_group_recursive:32:4:recursive + onehot_fp128_multi_group_recursive:32:4:recursive - name: 6-multi-group-recursive-w8r2 cases: | - onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2:32:4:recursive + onehot_fp128_multi_group_recursive_multi_chunk_w8r2:32:4:recursive - name: 7-distributed cases: | - onehot_fp128_d64_multi_chunk_w2r2:32:1 - onehot_fp128_d64_multi_chunk_w4r2:32:1 - onehot_fp128_d64_multi_chunk_w8r2:32:1 + onehot_fp128_multi_chunk_w2r2:32:1 + onehot_fp128_multi_chunk_w4r2:32:1 + onehot_fp128_multi_chunk_w8r2:32:1 steps: - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 with: diff --git a/book/src/usage/feature-flags.md b/book/src/usage/feature-flags.md index fee716762..eed5c2ce5 100644 --- a/book/src/usage/feature-flags.md +++ b/book/src/usage/feature-flags.md @@ -22,5 +22,5 @@ Disable parallel locally: `cargo build --no-default-features` (or add only the f | `profile-ci` | Schedule features needed for the CI profile-bench matrix (see [Profiling](./profiling.md)) | Per-crate feature tables live in each `crates/*/Cargo.toml`. -Schedule catalog features (`schedules-fp128-d64-onehot`, etc.) are documented in +Schedule catalog features (`schedules-fp128-onehot`, etc.) are documented in [Configuration and planning](../how/configuration.md). diff --git a/book/src/usage/jolt-recursion.md b/book/src/usage/jolt-recursion.md index 232e0b413..f4acea36a 100644 --- a/book/src/usage/jolt-recursion.md +++ b/book/src/usage/jolt-recursion.md @@ -4,10 +4,11 @@ The standalone `profile/akita-recursion/` sub-workspace (excluded from the main workspace; Rust 1.95 + RISC-V): the artifact → host → guest flow, the -`AkitaJoltInputs` blob, cycle accounting (Jolt guest pins **`fp128::D64OneHot`**; -D=32 A-role presets are removed), the trusted-benchmark vs production-validation -distinction, and the nv=32 full-prove trace-length limit. Link the sub-workspace -README rather than duplicating its cycle tables. +`AkitaJoltInputs` blob, cycle accounting (Jolt guest pins **`fp128::OneHot`** +at its D256 root envelope; D=32 A-role presets are removed), the +trusted-benchmark vs production-validation distinction, and the nv=32 +full-prove trace-length limit. Link the sub-workspace README rather than +duplicating its cycle tables. **Akita revision pinning:** hosts must pin an exact Akita git tag or commit. The zk-strip migration used a temporary pinned-proof-byte test diff --git a/book/src/usage/profiling.md b/book/src/usage/profiling.md index 833be6a55..9322e592e 100644 --- a/book/src/usage/profiling.md +++ b/book/src/usage/profiling.md @@ -6,41 +6,44 @@ traces, and the CI benchmark matrix. ## Canonical command ```bash -AKITA_MODE=onehot_fp128_d64 AKITA_NUM_VARS=32 \ +AKITA_MODE=onehot_fp128 AKITA_NUM_VARS=32 \ cargo run --release --no-default-features \ - --features parallel,profile-onehot-fp128-d64 --example profile + --features parallel,profile-onehot-fp128 --example profile ``` Run from `crates/akita-pcs/`. The harness refuses debug builds unless `AKITA_ALLOW_DEBUG_PROFILE=1`. +This feature-pruned command measures the adaptive `onehot_fp128` catalog. With +the normal default feature set, omitting `AKITA_MODE` selects the same profile. + Always use the feature-pruned command above when profiling this path or measuring its binary size/codegen time. An unpruned default-feature build of the `profile` example retains every locally supported profile mode; it is a -multi-mode developer artifact, not a like-for-like onehot fp128/D64 binary. +multi-mode developer artifact, not a like-for-like fp128 one-hot binary. Mixing the two build surfaces can roughly double the example binary and make a normal release link look like a verifier regression. ## Presets and ring degrees -Under committed-fold A-role SIS pricing, **fp128** production is **D=64** -(signed-sparse; ~20% smaller than D128). -Shipped tables: `fp128_d64_onehot`, `fp128_d64_dense`, `fp128_d128_*`. +The default direct **fp128** one-hot preset is adaptive: generated tables choose +the first two fold levels and use D64 for the uniform suffix. Direct dense uses +the same adaptive policy. Recursive and multi-chunk companion presets +remain D64. Shipped direct tables are `fp128_onehot` and `fp128_dense`. **fp128 D=32** is not a valid A-role fold degree (`d_a ≥ 64`); there is no `D32OneHot` preset. **fp32/fp64** D32/D64 are not securable; smallest secure choice is **D128 one-hot** (CI benches at `nv=28`). -Compare ring degrees with -`akita_config::proof_optimized::fp128::best_onehot_schedule` / -`best_dense_schedule`. +The direct configs are `akita_config::proof_optimized::fp128::OneHot` and +`akita_config::proof_optimized::fp128::Dense`. ## Environment knobs | Variable | Default | Purpose | |----------|---------|---------| -| `AKITA_MODE` | `onehot_fp128_d64` | Preset family and representation | -| `AKITA_NUM_VARS` | `25` in code (`32` in canonical command above) | Witness size | +| `AKITA_MODE` | `onehot_fp128` | Preset family and representation | +| `AKITA_NUM_VARS` | `32` | Witness size | | `AKITA_NUM_POLYS` | `1` | Batched opening count | | `AKITA_PROFILE_TRACE` | `1` | Chrome/Perfetto trace output | | `AKITA_PROFILE_LOG` | `trace` | `tracing` filter | @@ -55,9 +58,9 @@ Implementation: `crates/akita-pcs/examples/profile/main.rs`. Disable parallel while retaining the same pruned workload: ```bash -AKITA_MODE=onehot_fp128_d64 AKITA_NUM_VARS=32 \ +AKITA_MODE=onehot_fp128 AKITA_NUM_VARS=32 \ cargo run --release --no-default-features \ - --features profile-onehot-fp128-d64 --example profile + --features profile-onehot-fp128 --example profile ``` ## CI benchmark matrix @@ -73,15 +76,14 @@ Committed-fold A-role pricing (every cell folds securely): |------|----|----|------------| | `onehot_fp32_d128` | 28 | 1 | `direct` | | `onehot_fp64_d128` | 28 | 1 | `direct` | -| `dense_fp128_d64` | 24 | 1 | `direct` | -| `onehot_fp128_d64` | 32 | 1 | `direct` | -| `onehot_fp128_d64` | 30 | 4 | `direct` | -| `onehot_fp128_d64_multi_group_recursive` | 32 | 4 | `direct` | -| `onehot_fp128_d64_multi_group_recursive` | 32 | 4 | `recursive` | -| `onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2` | 32 | 4 | `recursive` | -| `onehot_fp128_d64_multi_chunk_w2r2` | 32 | 1 | `direct` | -| `onehot_fp128_d64_multi_chunk_w4r2` | 32 | 1 | `direct` | -| `onehot_fp128_d64_multi_chunk_w8r2` | 32 | 1 | `direct` | +| `dense_fp128` | 24 | 1 | `direct` | +| `onehot_fp128` | 32 | 1 | `direct` | +| `onehot_fp128_multi_group` | 32 | 4 | `direct` | +| `onehot_fp128_multi_group_recursive` | 32 | 4 | `recursive` | +| `onehot_fp128_multi_group_recursive_multi_chunk_w8r2` | 32 | 4 | `recursive` | +| `onehot_fp128_multi_chunk_w2r2` | 32 | 1 | `direct` | +| `onehot_fp128_multi_chunk_w4r2` | 32 | 1 | `direct` | +| `onehot_fp128_multi_chunk_w8r2` | 32 | 1 | `direct` | fp32/fp64 use `nv=28` because the ext-degree-4 challenge schedule exceeds the 1 GiB `MAX_MATERIALIZED_EQ_TABLE_BYTES` budget at higher `num_vars`. diff --git a/book/src/usage/quickstart.md b/book/src/usage/quickstart.md index 0febbb433..f031831eb 100644 --- a/book/src/usage/quickstart.md +++ b/book/src/usage/quickstart.md @@ -15,7 +15,7 @@ a newcomer should reach for first. - `crates/akita-pcs/tests/single_poly_e2e.rs` (smallest E2E template). - `AGENTS.md` (Essential Commands); `crates/akita-pcs/examples/profile/main.rs` - (`AKITA_MODE=onehot_fp128_d64`, `AKITA_NUM_VARS=32`). + (`AKITA_MODE=onehot_fp128`, `AKITA_NUM_VARS=32`). ## Choosing a configuration @@ -23,24 +23,23 @@ How the `fp32` / `fp64` / `fp128` preset families differ, when to choose one-hot vs dense, and how ring dimension `D` trades proof size against prover time and setup memory. -**Paper framing (§3.5 `sec:akita-params`).** Production uses **d=64** with the -signed-sparse challenge family. **d=128** remains a comparison / legacy profile; -**d=32** is not a valid A-role fold degree (`d_a ≥ 64`). +**Paper framing (§3.5 `sec:akita-params`).** The uniform production profile uses +**d=64** with the signed-sparse challenge family. The default direct fp128 +one-hot preset now chooses dimensions per fold from generated adaptive tables; +**d=32** remains invalid for the A-role fold degree (`d_a ≥ 64`). **Proof-size / CI reality (committed-fold A-role SIS pricing).** | Field | Typical production choice | Notes | |-------|---------------------------|--------| -| **fp128** | **D64 one-hot** (`onehot_fp128_d64`) | **Production default** (Paper §3.5 signed-sparse at d=64). Planner picks **D64 over D128** (~20% smaller proof); both fold securely. Shipped tables: D128 dense/onehot, D64 dense/onehot. Jolt recursion and profile defaults pin **`fp128::D64OneHot`**. | +| **fp128** | **One-hot** (`fp128::OneHot`) | **Default direct one-hot preset.** The generated schedule chooses dimensions for the first two fold levels and uses D64 afterward. Direct dense uses `fp128::Dense`; recursive/tensor/multi-chunk companions remain pinned to D64. | | **fp32 / fp64** | **D128 one-hot** | D32/D64 are **not securable** under the reprice and unsupported schedules fail fast. CI benches at **nv=28** (eq-table memory budget). Shipped: fp32 D128/D256 onehot; fp64 D128 dense/onehot and D256 onehot. | -Use `akita_config::proof_optimized::fp128::best_onehot_schedule` / -`best_dense_schedule` to compare fp128 **D64 vs D128** for a lookup key. Every preset -falls back to the verifier-reachable DP on table miss. +Use `fp128::OneHot` for direct one-hot and `fp128::Dense` for direct dense. **Test harness vs profile defaults.** `crates/akita-pcs/tests/common/mod.rs` uses -`fp128::D64OneHot` (one-hot) and `fp128::D64Dense` (dense tests); profile/CI -canonical dense is **`fp128::D64Dense`** at D64. +direct protocol tests should use `fp128::OneHot` and `fp128::Dense`; specialized +recursive, tensor, and multi-chunk tests use their dedicated D64 companions. **Sources to fold in** diff --git a/crates/akita-config/Cargo.toml b/crates/akita-config/Cargo.toml index db8cfbcd5..f54859b3e 100644 --- a/crates/akita-config/Cargo.toml +++ b/crates/akita-config/Cargo.toml @@ -20,11 +20,8 @@ readme = "../../README.md" default = ["schedules-default"] test-support = [] schedules-default = [ - "schedules-fp128-d64-onehot", - "schedules-fp128-d64-dense", - "schedules-fp128-d128-onehot", - "schedules-fp128-d128-dense", - "schedules-fp128-d256-onehot", + "schedules-fp128-onehot", + "schedules-fp128-dense", "schedules-fp32-d128-onehot", "schedules-fp32-d256-onehot", "schedules-fp64-d128-dense", @@ -33,38 +30,29 @@ schedules-default = [ ] all-schedules = [ "schedules-default", - "schedules-fp128-mixed-dim-onehot", - "schedules-fp128-d64-onehot-recursive", - "schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2", - "schedules-fp128-d64-onehot-multi-chunk", - "schedules-fp128-d64-onehot-multi-chunk-w2r2", - "schedules-fp128-d64-onehot-multi-chunk-w4r2", - "schedules-fp128-d64-dense-multi-chunk", + "schedules-fp128-onehot-recursive", + "schedules-fp128-onehot-recursive-multi-chunk-w8r2", + "schedules-fp128-onehot-multi-chunk", + "schedules-fp128-onehot-multi-chunk-w2r2", + "schedules-fp128-onehot-multi-chunk-w4r2", + "schedules-fp128-dense-multi-chunk", ] -schedules-fp128-d64-onehot = ["akita-schedules/fp128-d64-onehot"] -schedules-fp128-mixed-dim-onehot = ["akita-schedules/fp128-mixed-dim-onehot"] -schedules-fp128-d64-onehot-recursive = [ - "akita-schedules/fp128-d64-onehot-recursive", +schedules-fp128-onehot = ["akita-schedules/fp128-onehot"] +schedules-fp128-dense = ["akita-schedules/fp128-dense"] +schedules-fp128-onehot-recursive = ["akita-schedules/fp128-onehot-recursive"] +schedules-fp128-onehot-recursive-multi-chunk-w8r2 = [ + "akita-schedules/fp128-onehot-recursive-multi-chunk-w8r2", ] -schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2 = [ - "akita-schedules/fp128-d64-onehot-recursive-multi-chunk-w8r2", +schedules-fp128-onehot-multi-chunk = [ + "akita-schedules/fp128-onehot-multi-chunk", ] -schedules-fp128-d64-dense = ["akita-schedules/fp128-d64-dense"] -schedules-fp128-d128-onehot = ["akita-schedules/fp128-d128-onehot"] -schedules-fp128-d128-dense = ["akita-schedules/fp128-d128-dense"] -schedules-fp128-d256-onehot = ["akita-schedules/fp128-d256-onehot"] -schedules-fp128-d64-onehot-multi-chunk = [ - "akita-schedules/fp128-d64-onehot-multi-chunk", +schedules-fp128-onehot-multi-chunk-w2r2 = [ + "akita-schedules/fp128-onehot-multi-chunk-w2r2", ] -schedules-fp128-d64-onehot-multi-chunk-w2r2 = [ - "akita-schedules/fp128-d64-onehot-multi-chunk-w2r2", -] -schedules-fp128-d64-onehot-multi-chunk-w4r2 = [ - "akita-schedules/fp128-d64-onehot-multi-chunk-w4r2", -] -schedules-fp128-d64-dense-multi-chunk = [ - "akita-schedules/fp128-d64-dense-multi-chunk", +schedules-fp128-onehot-multi-chunk-w4r2 = [ + "akita-schedules/fp128-onehot-multi-chunk-w4r2", ] +schedules-fp128-dense-multi-chunk = ["akita-schedules/fp128-dense-multi-chunk"] schedules-fp32-d128-onehot = ["akita-schedules/fp32-d128-onehot"] schedules-fp32-d256-onehot = ["akita-schedules/fp32-d256-onehot"] @@ -89,7 +77,7 @@ akita-planner = { version = "0.1.0", path = "../akita-planner", features = [ [[test]] name = "schedule_catalog_miswire" path = "tests/schedule_catalog_miswire.rs" -required-features = ["schedules-fp128-d64-onehot", "schedules-fp128-d64-dense"] +required-features = ["schedules-fp128-onehot", "schedules-fp128-dense"] [[test]] name = "generated_tables" diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index 166bc490b..83fe7bf72 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -10,15 +10,14 @@ use akita_challenges::SparseChallengeConfig; use akita_field::{ AkitaError, CanonicalField, ExtField, FieldCore, FromPrimitiveInt, MulBaseUnreduced, }; -use akita_schedules::PlannerPolicy; +use akita_schedules::{PlannerPolicy, RingDimensionScheduleMode}; use akita_serialization::Valid; use akita_transcript::{append_ext_field, sample_ext_challenge, Transcript}; #[cfg(test)] use akita_types::PolynomialGroupLayout; use akita_types::{ - AkitaScheduleLookupKey, ChunkedWitnessCfg, CommitmentRingDims, CommittedGroupParams, - DecompositionParams, FoldSchedule, OpeningClaimsLayout, SetupMatrixCapacity, - SisModulusProfileId, + AkitaScheduleLookupKey, ChunkedWitnessCfg, CommittedGroupParams, DecompositionParams, + FoldSchedule, OpeningClaimsLayout, SetupMatrixCapacity, SisModulusProfileId, }; /// Define a multi-chunk companion preset that delegates every layout-affecting @@ -35,8 +34,8 @@ macro_rules! impl_multi_chunk_companion { type Field = <$base as $crate::CommitmentConfig>::Field; type ExtField = <$base as $crate::CommitmentConfig>::ExtField; const D: usize = <$base as $crate::CommitmentConfig>::D; - const RING_DIMENSION_CANDIDATES: &'static [akita_types::CommitmentRingDims] = - <$base as $crate::CommitmentConfig>::RING_DIMENSION_CANDIDATES; + const RING_DIMENSION_SCHEDULE_MODE: akita_schedules::RingDimensionScheduleMode = + <$base as $crate::CommitmentConfig>::RING_DIMENSION_SCHEDULE_MODE; const EXT_DEGREE: usize = <$base as $crate::CommitmentConfig>::EXT_DEGREE; fn decomposition() -> akita_types::DecompositionParams { @@ -131,7 +130,7 @@ pub fn policy_of() -> PlannerPolicy { min_offloaded_witness_contraction: 3, uniform_ring_dimension: Cfg::D, setup_prefix_inner_ring_dimension: Cfg::setup_prefix_inner_ring_dimension(), - ring_dimension_candidates: Cfg::RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: Cfg::RING_DIMENSION_SCHEDULE_MODE, decomposition: Cfg::decomposition(), sis_modulus_profile: Cfg::sis_modulus_profile(), sis_security_policy: akita_types::DEFAULT_SIS_SECURITY_POLICY, @@ -199,12 +198,11 @@ pub trait CommitmentConfig: Clone + Send + Sync + 'static { /// Ring degree used by `CyclotomicRing`. const D: usize; - /// Canonically ordered A/B/D tuples admitted by offline schedule search. - /// - /// Uniform presets use their setup-generation dimension for every role. - /// Adaptive presets override this with their full audited search domain. - const RING_DIMENSION_CANDIDATES: &'static [CommitmentRingDims] = - &[CommitmentRingDims::uniform(Self::D)]; + /// Uniform or bounded-adaptive ring-dimension schedule policy. + const RING_DIMENSION_SCHEDULE_MODE: RingDimensionScheduleMode = + RingDimensionScheduleMode::UniformDimension { + ring_dimension: Self::D, + }; /// Gadget base + coefficient bounds. fn decomposition() -> DecompositionParams; @@ -268,10 +266,11 @@ pub trait CommitmentConfig: Clone + Send + Sync + 'static { max_num_batched_polys: usize, ) -> Result; - /// Planner-owned A-matrix ring dimension for setup-prefix commitments. + /// Default/ceiling A-matrix dimension for setup-prefix commitments. /// - /// This controls how the explicitly zero-padded setup-prefix witness is - /// chunked for commitment. It is not public-matrix identity or a setup + /// Uniform schedules use it directly. Adaptive recursive schedules derive + /// the actual A dimension from the consuming fold; this value remains part + /// of policy/catalog identity. It is not public-matrix identity or a setup /// materialization dimension. fn setup_prefix_inner_ring_dimension() -> usize { Self::D @@ -639,17 +638,46 @@ mod fp128_policy_tests { const CI_SIS_WIDTH_NUM_VARS: &[usize] = &[14, 16, 28, 30, 44, 50]; #[test] - fn current_d64_dense_schedule_stays_within_audited_sis_widths() { - assert_cfg_schedule_stays_within_audited_sis_widths::( - CI_SIS_WIDTH_NUM_VARS, - ); + fn fp128_onehot_uses_adaptive_schedule_policy() { + assert_eq!(::D, 256); + assert!(matches!( + ::RING_DIMENSION_SCHEDULE_MODE, + RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels: 2, + uniform_suffix_dimension: 64, + .. + } + )); + assert!(fp128::OneHot::schedule_catalog().is_some()); } #[test] - fn current_d64_onehot_schedule_stays_within_audited_sis_widths() { - assert_cfg_schedule_stays_within_audited_sis_widths::( - CI_SIS_WIDTH_NUM_VARS, - ); + fn fp128_dense_uses_adaptive_schedule_policy() { + assert_eq!(::D, 256); + assert!(matches!( + ::RING_DIMENSION_SCHEDULE_MODE, + RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels: 2, + uniform_suffix_dimension: 64, + .. + } + )); + assert!(fp128::Dense::schedule_catalog().is_some()); + } + + #[test] + fn current_dense_schedule_stays_within_audited_sis_widths() { + assert_cfg_schedule_stays_within_audited_sis_widths::(CI_SIS_WIDTH_NUM_VARS); + } + + #[test] + fn current_adaptive_dense_schedule_stays_within_audited_sis_widths() { + assert_cfg_schedule_stays_within_audited_sis_widths::(CI_SIS_WIDTH_NUM_VARS); + } + + #[test] + fn current_onehot_schedule_stays_within_audited_sis_widths() { + assert_cfg_schedule_stays_within_audited_sis_widths::(CI_SIS_WIDTH_NUM_VARS); } #[test] @@ -658,7 +686,7 @@ mod fp128_policy_tests { type SmallCfg = fp32::D128OneHot; assert_eq!( - ::ring_subfield_embedding_norm_bound(), + ::ring_subfield_embedding_norm_bound(), 1 ); assert_eq!( @@ -678,33 +706,26 @@ mod fp128_policy_tests { } #[test] - fn fp128_family_selector_uses_generated_singleton_plans() { + fn fp128_generated_singleton_plans_resolve() { let key = PolynomialGroupLayout::singleton(32); - let dense = fp128::best_dense_schedule(key) - .expect("selector should resolve dense schedules") - .expect("selector should find a generated dense schedule"); - let onehot = fp128::best_onehot_schedule(key) - .expect("selector should resolve onehot schedules") - .expect("selector should find a generated onehot schedule"); + let dense = fp128::Dense::runtime_schedule(AkitaScheduleLookupKey::single(key)) + .expect("adaptive dense schedule"); + let onehot = fp128::OneHot::runtime_schedule(AkitaScheduleLookupKey::single(key)) + .expect("adaptive onehot schedule"); - for selection in [&dense, &onehot] { - assert_eq!(selection.schedule.initial_witness_len(), 1usize << 32); - } - assert!(!dense.preset.is_onehot()); - assert!(onehot.preset.is_onehot()); + assert_eq!(dense.initial_witness_len(), 1usize << 32); + assert_eq!(onehot.initial_witness_len(), 1usize << 32); } #[test] - fn fp128_family_selector_supports_batched_keys() { + fn fp128_adaptive_onehot_supports_batched_keys() { let key = PolynomialGroupLayout::new(30, 4); - let selection = fp128::best_onehot_schedule(key) - .expect("selector should resolve batched onehot schedules") - .expect("selector should find a generated batched onehot schedule"); + let schedule = fp128::OneHot::runtime_schedule(AkitaScheduleLookupKey::single(key)) + .expect("adaptive batched onehot schedule"); - assert!(selection.preset.is_onehot()); - assert_eq!(selection.schedule.initial_witness_len(), 1usize << 30); + assert_eq!(schedule.initial_witness_len(), 1usize << 30); } } @@ -720,16 +741,24 @@ mod precommit_tests { let singleton = OpeningClaimsLayout::new(group.num_vars(), group.num_polynomials()).expect("singleton"); let params = - as CommitmentConfig>::get_params_for_batched_commitment( + as CommitmentConfig>::get_params_for_batched_commitment( &singleton, ) .expect("precommitted group params"); let precommitted = akita_types::CommittedGroupProfile::from_params(group, ¶ms); - let root_basis = fp128::D64OneHot::basis_range().0; + assert_eq!( + precommitted.inner_commit_matrix.ring_dimension(), + 64, + "adaptive precommits use the uniform suffix dimension for A" + ); + assert_eq!( + precommitted.outer_commit_matrix.ring_dimension(), + 64, + "adaptive precommits use the uniform suffix dimension for B" + ); + let root_basis = fp128::OneHot::basis_range().0; assert_eq!(precommitted.log_basis_inner, root_basis); assert_eq!(precommitted.log_basis_outer, root_basis); - assert_eq!(precommitted.num_positions_per_block, 256); - assert_eq!(precommitted.num_live_blocks, 4); assert_ne!(precommitted.inner_commit_matrix.output_rank(), 0); assert_ne!(precommitted.outer_commit_matrix.output_rank(), 0); } @@ -738,7 +767,7 @@ mod precommit_tests { fn precommit_config_rejects_prove_schedule() { let layout = OpeningClaimsLayout::new(2, 1).expect("opening layout"); let err = - as CommitmentConfig>::get_params_for_prove( + as CommitmentConfig>::get_params_for_prove( &layout, ) .expect_err("precommit config must not prove"); diff --git a/crates/akita-config/src/precommitted_commitment.rs b/crates/akita-config/src/precommitted_commitment.rs index 5e9dad308..8fd3161f3 100644 --- a/crates/akita-config/src/precommitted_commitment.rs +++ b/crates/akita-config/src/precommitted_commitment.rs @@ -3,16 +3,17 @@ //! This adapter is for staggered workflows that need ordinary commit calls to //! freeze the A/source and B/outer commitment layout before the final multi-group //! root is known. The root basis is deterministic from the base config's runtime -//! catalog policy, so precommitments use the exact root layout rather than a -//! worst-case envelope over every supported basis. +//! catalog policy. Adaptive base configurations use their uniform suffix +//! dimension so a precommit recipe does not depend on a hypothetical future +//! final-group schedule. use crate::{policy_of, CommitmentConfig}; use akita_challenges::SparseChallengeConfig; use akita_field::AkitaError; use akita_types::{ - accumulate_matrix_field_elements_for_level, CommitmentRingDims, CommittedGroupParams, - CommittedGroupProfile, DecompositionParams, FoldSchedule, OpenCommitMatrixParams, - OpeningClaimsLayout, PolynomialGroupLayout, SetupMatrixCapacity, SisModulusProfileId, + accumulate_matrix_field_elements_for_level, CommittedGroupParams, CommittedGroupProfile, + DecompositionParams, FoldSchedule, OpenCommitMatrixParams, OpeningClaimsLayout, + PolynomialGroupLayout, SetupMatrixCapacity, SisModulusProfileId, }; use std::marker::PhantomData; @@ -26,7 +27,8 @@ impl CommitmentConfig for PrecommittedCommitmentConfig DecompositionParams { Cfg::decomposition() @@ -182,8 +184,8 @@ mod tests { #[test] fn same_layout_can_resolve_config_specific_profiles() { let key = PolynomialGroupLayout::new(16, 1); - let dense = committed_group_params::(&key).expect("dense params"); - let one_hot = committed_group_params::(&key).expect("one-hot params"); + let dense = committed_group_params::(&key).expect("dense params"); + let one_hot = committed_group_params::(&key).expect("one-hot params"); assert_ne!( CommittedGroupProfile::from_params(key, &dense), CommittedGroupProfile::from_params(key, &one_hot), @@ -194,7 +196,9 @@ mod tests { #[test] fn dense_precommit_profile_uses_dense_config() { let key = PolynomialGroupLayout::new(15, 2); - let params = committed_group_params::(&key).expect("dense params"); + let params = committed_group_params::(&key).expect("dense params"); + assert_eq!(params.inner_commit_matrix.ring_dimension(), 64); + assert_eq!(params.outer_commit_matrix.ring_dimension(), 64); assert_eq!(params.log_basis_inner, 3); assert_eq!(params.log_basis_outer, 3); assert_eq!(params.num_digits_inner, 43); diff --git a/crates/akita-config/src/proof_optimized.rs b/crates/akita-config/src/proof_optimized.rs index 12e8adfbe..9338f3542 100644 --- a/crates/akita-config/src/proof_optimized.rs +++ b/crates/akita-config/src/proof_optimized.rs @@ -46,8 +46,9 @@ const DEFAULT_GROUP_BATCH_MAX_PRECOMMITTED_GROUPS: usize = 2; /// /// Fixed-weight sparse families keyed on ring degree `d` via /// [`akita_challenges::SparseChallengeConfig::production_for_ring_dim`]. -/// A preset's `D` is fixed across all schedule levels, so both the planner DP -/// and the generated-table expansion call the per-`Cfg` hook with `d == Cfg::D`. +/// The planner and generated-table expansion call this hook with each +/// schedule-selected A dimension. The flat public matrix has no generation +/// dimension. pub(crate) fn proof_optimized_ring_challenge_config( d: usize, ) -> Result { @@ -139,6 +140,32 @@ fn proof_optimized_setup_matrix_capacity_uncached( // Size those schedules from their canonical keys: synthesizing an opening // layout at `max_num_vars` can miss a finite-catalog precommit arity. if let Some(catalog) = Cfg::schedule_catalog() { + let policy = crate::policy_of::(); + for &row in catalog.precommitted_profiles { + let profile = row.expand_to_committed_profile(&policy)?; + if profile.group.num_vars() > max_num_vars + || profile.group.num_polynomials() > max_num_batched_polys + { + continue; + } + let a_coeff_len = matrix_coefficient_len( + profile.inner_commit_matrix.output_rank(), + profile.inner_commit_matrix.input_width(), + profile.inner_commit_matrix.ring_dimension(), + "precommit A", + )?; + let b_coeff_len = matrix_coefficient_len( + profile.outer_commit_matrix.output_rank(), + profile.outer_commit_matrix.input_width(), + profile.outer_commit_matrix.ring_dimension(), + "precommit B", + )?; + saw_supported_shape = true; + envelope.num_field_elements = envelope + .num_field_elements + .max(a_coeff_len) + .max(b_coeff_len); + } for entry in catalog.entries { if entry.root.precommitted_groups.is_empty() { continue; @@ -405,11 +432,10 @@ fn matrix_coefficient_len( macro_rules! impl_proof_optimized_preset { (@selection_policy default) => { fn selection_policy() -> akita_schedules::SelectionPolicyId { - if Self::recursive_setup_planning() { - akita_schedules::SelectionPolicyId::MinFirstDirectSetupThenPayload - } else { - akita_schedules::SelectionPolicyId::MinEstimatedProofPayload - } + akita_schedules::SelectionPolicyId::for_policy( + Self::recursive_setup_planning(), + Self::RING_DIMENSION_SCHEDULE_MODE, + ) } }; (@selection_policy $selection_policy:expr) => { @@ -430,9 +456,9 @@ macro_rules! impl_proof_optimized_preset { } } }; - (@ring_dimension_candidates) => {}; - (@ring_dimension_candidates $candidates:expr) => { - const RING_DIMENSION_CANDIDATES: &'static [akita_types::CommitmentRingDims] = $candidates; + (@ring_dimension_schedule_mode) => {}; + (@ring_dimension_schedule_mode $mode:expr) => { + const RING_DIMENSION_SCHEDULE_MODE: akita_schedules::RingDimensionScheduleMode = $mode; }; ($cfg:ident, $field:ty, $ext_field:ty, $family:expr, $d:expr, $field_bits:expr, $log_commit_bound:expr, fold_norms = $fold_norms:expr) => { impl_proof_optimized_preset!(@core $cfg, $field, $ext_field, $family, $d, $field_bits, $log_commit_bound, $fold_norms, none, default); @@ -443,11 +469,11 @@ macro_rules! impl_proof_optimized_preset { ($cfg:ident, $field:ty, $ext_field:ty, $family:expr, $d:expr, $field_bits:expr, $log_commit_bound:expr, fold_norms = $fold_norms:expr, schedules = ($feat:literal, $family_name:literal, $table:ident), selection_policy = $selection_policy:expr) => { impl_proof_optimized_preset!(@core $cfg, $field, $ext_field, $family, $d, $field_bits, $log_commit_bound, $fold_norms, table, $feat, $family_name, $table, selection_policy = $selection_policy); }; - ($cfg:ident, $field:ty, $ext_field:ty, $family:expr, $d:expr, $field_bits:expr, $log_commit_bound:expr, fold_norms = $fold_norms:expr, schedules = ($feat:literal, $family_name:literal, $table:ident), ring_dimension_candidates = $candidates:expr) => { - impl_proof_optimized_preset!(@core $cfg, $field, $ext_field, $family, $d, $field_bits, $log_commit_bound, $fold_norms, table, $feat, $family_name, $table, ring_dimension_candidates = $candidates); + ($cfg:ident, $field:ty, $ext_field:ty, $family:expr, $d:expr, $field_bits:expr, $log_commit_bound:expr, fold_norms = $fold_norms:expr, schedules = ($feat:literal, $family_name:literal, $table:ident), ring_dimension_schedule_mode = $mode:expr) => { + impl_proof_optimized_preset!(@core $cfg, $field, $ext_field, $family, $d, $field_bits, $log_commit_bound, $fold_norms, table, $feat, $family_name, $table, ring_dimension_schedule_mode = $mode); }; - ($cfg:ident, $field:ty, $ext_field:ty, $family:expr, $d:expr, $field_bits:expr, $log_commit_bound:expr, fold_norms = $fold_norms:expr, schedules = ($feat:literal, $family_name:literal, $table:ident), selection_policy = $selection_policy:expr, ring_dimension_candidates = $candidates:expr) => { - impl_proof_optimized_preset!(@core $cfg, $field, $ext_field, $family, $d, $field_bits, $log_commit_bound, $fold_norms, table, $feat, $family_name, $table, selection_policy = $selection_policy, ring_dimension_candidates = $candidates); + ($cfg:ident, $field:ty, $ext_field:ty, $family:expr, $d:expr, $field_bits:expr, $log_commit_bound:expr, fold_norms = $fold_norms:expr, schedules = ($feat:literal, $family_name:literal, $table:ident), selection_policy = $selection_policy:expr, ring_dimension_schedule_mode = $mode:expr) => { + impl_proof_optimized_preset!(@core $cfg, $field, $ext_field, $family, $d, $field_bits, $log_commit_bound, $fold_norms, table, $feat, $family_name, $table, selection_policy = $selection_policy, ring_dimension_schedule_mode = $mode); }; (@options default) => { impl_proof_optimized_preset!(@selection_policy default); @@ -455,12 +481,12 @@ macro_rules! impl_proof_optimized_preset { (@options selection_policy = $selection_policy:expr) => { impl_proof_optimized_preset!(@selection_policy $selection_policy); }; - (@options ring_dimension_candidates = $candidates:expr) => { - impl_proof_optimized_preset!(@ring_dimension_candidates $candidates); + (@options ring_dimension_schedule_mode = $mode:expr) => { + impl_proof_optimized_preset!(@ring_dimension_schedule_mode $mode); impl_proof_optimized_preset!(@selection_policy default); }; - (@options selection_policy = $selection_policy:expr, ring_dimension_candidates = $candidates:expr) => { - impl_proof_optimized_preset!(@ring_dimension_candidates $candidates); + (@options selection_policy = $selection_policy:expr, ring_dimension_schedule_mode = $mode:expr) => { + impl_proof_optimized_preset!(@ring_dimension_schedule_mode $mode); impl_proof_optimized_preset!(@selection_policy $selection_policy); }; (@core $cfg:ident, $field:ty, $ext_field:ty, $family:expr, $d:expr, $field_bits:expr, $log_commit_bound:expr, $fold_norms:expr, none, $($options:tt)*) => { diff --git a/crates/akita-config/src/proof_optimized/fp128.rs b/crates/akita-config/src/proof_optimized/fp128.rs index 3b9588c6f..75cbb8c13 100644 --- a/crates/akita-config/src/proof_optimized/fp128.rs +++ b/crates/akita-config/src/proof_optimized/fp128.rs @@ -6,170 +6,67 @@ use super::*; /// Base field for the default fp128 presets. pub type Field = Prime128OffsetA7F7; -/// Dense `D=128` preset for planner-backed experiments. +/// Default dense preset with a dimension-free flat public matrix and +/// planner-selected per-level A/B/D commitment dimensions. #[derive(Clone, Copy, Debug, Default)] -pub struct D128Dense; +pub struct Dense; -/// Dense adaptive `D=64` preset. -#[derive(Clone, Copy, Debug, Default)] -pub struct D64Dense; - -/// Binary onehot generated `D=64` preset. -#[derive(Clone, Copy, Debug, Default)] -pub struct D64OneHot; - -/// Binary onehot `D=64`, `K=16` preset with planner-derived schedules. -#[derive(Clone, Copy, Debug, Default)] -pub struct D64OneHotK16; - -/// Binary onehot `D=128`, `K=256` preset for planner-backed experiments. -#[derive(Clone, Copy, Debug, Default)] -pub struct D128OneHot; - -/// Binary onehot `D=256` tableless preset for mixed-ring experiments. -/// fp128 certifies all three commitment roles at this dimension. -#[derive(Clone, Copy, Debug, Default)] -pub struct D256OneHot; +impl Dense { + pub const A_RING_DIMENSIONS: [usize; 3] = [64, 128, 256]; + pub const B_RING_DIMENSIONS: [usize; 2] = [64, 128]; + pub const D_RING_DIMENSIONS: [usize; 2] = [64, 128]; +} -/// Binary onehot preset with a D256 uniform planner policy and planner-selected -/// per-level commitment dimensions. +/// Default binary onehot preset with a dimension-free flat public matrix and +/// planner-selected per-level A/B/D commitment dimensions. /// /// Mixed-dimension planning is an offline generation step. Runtime proving /// and verification resolve the exact generated catalog row. #[derive(Clone, Copy, Debug, Default)] -pub struct MixedDimFp128OneHot; +pub struct OneHot; -impl MixedDimFp128OneHot { - /// Audited commitment-role dimension candidates used by offline planning. - pub const RING_DIMENSION_CANDIDATES: [akita_types::CommitmentRingDims; 4] = [ - akita_types::CommitmentRingDims::uniform(64), - akita_types::CommitmentRingDims { - inner: 128, - outer: 64, - opening: 64, - }, - akita_types::CommitmentRingDims::uniform(128), - akita_types::CommitmentRingDims { - inner: 256, - outer: 128, - opening: 128, - }, - ]; +impl OneHot { + pub const A_RING_DIMENSIONS: [usize; 3] = [64, 128, 256]; + pub const B_RING_DIMENSIONS: [usize; 2] = [64, 128]; + pub const D_RING_DIMENSIONS: [usize; 2] = [64, 128]; } -/// Tableless policy marker for a `D = 512` inner (A-role) root. -/// -/// fp128 certifies the A role at `D = 512` for the Q128 profile, but not B/D. -/// Consequently this preset is used only as the envelope type for the -/// three-band mixed-role builder, which keeps B/D within their audited -/// dimensions; it cannot produce a standalone uniform-D512 schedule. +/// Direct multi-chunk companion of [`OneHot`] using the W8R2 profile. #[derive(Clone, Copy, Debug, Default)] -pub struct D512OneHot; +pub struct OneHotMultiChunk; -/// Multi-chunk (distributed-prover) companion of [`D64OneHot`]. Shares every -/// layout parameter with its sibling but prices the chunked witness layout. +/// Direct multi-chunk companion of [`OneHot`] using the W2R2 profile. #[derive(Clone, Copy, Debug, Default)] -pub struct D64OneHotMultiChunk; +pub struct OneHotMultiChunkW2R2; -/// Multi-chunk companion with `2` witness chunks and `2` leading fold levels. +/// Direct multi-chunk companion of [`OneHot`] using the W4R2 profile. #[derive(Clone, Copy, Debug, Default)] -pub struct D64OneHotMultiChunkW2R2; +pub struct OneHotMultiChunkW4R2; -/// Multi-chunk companion with `4` witness chunks and `2` leading fold levels. +/// Direct multi-chunk companion of [`Dense`] using the W8R2 profile. #[derive(Clone, Copy, Debug, Default)] -pub struct D64OneHotMultiChunkW4R2; - -/// Multi-chunk (distributed-prover) companion of [`D64Dense`]. -#[derive(Clone, Copy, Debug, Default)] -pub struct D64DenseMultiChunk; +pub struct DenseMultiChunk; impl_proof_optimized_preset!( - D128Dense, + Dense, Field, Field, akita_types::SisModulusProfileId::Q128OffsetA7F7, - 128, - 128, - 128, - fold_norms = akita_types::sis::FoldWitnessNorms::bounded(3, 128), - schedules = ( - "schedules-fp128-d128-dense", - "fp128_d128_dense", - fp128_d128_dense_table - ) -); -impl_proof_optimized_preset!( - D128OneHot, - Field, - Field, - akita_types::SisModulusProfileId::Q128OffsetA7F7, - 128, - 128, - 1, - fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 1), - schedules = ( - "schedules-fp128-d128-onehot", - "fp128_d128_onehot", - fp128_d128_onehot_table - ) -); -impl_proof_optimized_preset!( - D64Dense, - Field, - Field, - akita_types::SisModulusProfileId::Q128OffsetA7F7, - 64, + 256, 128, 128, fold_norms = akita_types::sis::FoldWitnessNorms::bounded(3, 64), - schedules = ( - "schedules-fp128-d64-dense", - "fp128_d64_dense", - fp128_d64_dense_table - ) -); -impl_proof_optimized_preset!( - D64OneHot, - Field, - Field, - akita_types::SisModulusProfileId::Q128OffsetA7F7, - 64, - 128, - 1, - fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 1), - schedules = ( - "schedules-fp128-d64-onehot", - "fp128_d64_onehot", - fp128_d64_onehot_table - ) -); -impl_proof_optimized_preset!( - D64OneHotK16, - Field, - Field, - akita_types::SisModulusProfileId::Q128OffsetA7F7, - 64, - 128, - 1, - fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 4) -); -impl_proof_optimized_preset!( - D256OneHot, - Field, - Field, - akita_types::SisModulusProfileId::Q128OffsetA7F7, - 256, - 128, - 1, - fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 1), - schedules = ( - "schedules-fp128-d256-onehot", - "fp128_d256_onehot", - fp128_d256_onehot_table - ) + schedules = ("schedules-fp128-dense", "fp128_dense", fp128_dense_table), + ring_dimension_schedule_mode = akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels: akita_schedules::ADAPTIVE_SEARCH_LEVELS, + uniform_suffix_dimension: 64, + potential_a_dimensions: &Dense::A_RING_DIMENSIONS, + potential_b_dimensions: &Dense::B_RING_DIMENSIONS, + potential_d_dimensions: &Dense::D_RING_DIMENSIONS, + } ); impl_proof_optimized_preset!( - MixedDimFp128OneHot, + OneHot, Field, Field, akita_types::SisModulusProfileId::Q128OffsetA7F7, @@ -177,190 +74,40 @@ impl_proof_optimized_preset!( 128, 1, fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 1), - schedules = ( - "schedules-fp128-mixed-dim-onehot", - "fp128_mixed_dim_onehot", - fp128_mixed_dim_onehot_table - ), - selection_policy = - akita_schedules::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, - ring_dimension_candidates = &MixedDimFp128OneHot::RING_DIMENSION_CANDIDATES -); -impl_proof_optimized_preset!( - D512OneHot, - Field, - Field, - akita_types::SisModulusProfileId::Q128OffsetA7F7, - 512, - 128, - 1, - fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 2) + schedules = ("schedules-fp128-onehot", "fp128_onehot", fp128_onehot_table), + ring_dimension_schedule_mode = akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels: akita_schedules::ADAPTIVE_SEARCH_LEVELS, + uniform_suffix_dimension: 64, + potential_a_dimensions: &OneHot::A_RING_DIMENSIONS, + potential_b_dimensions: &OneHot::B_RING_DIMENSIONS, + potential_d_dimensions: &OneHot::D_RING_DIMENSIONS, + } ); impl_multi_chunk_companion!( - D64OneHotMultiChunk, - D64OneHot, + OneHotMultiChunk, + OneHot, akita_types::MultiChunkProfileId::W8R2, - "schedules-fp128-d64-onehot-multi-chunk", - fp128_d64_onehot_multi_chunk_table + "schedules-fp128-onehot-multi-chunk", + fp128_onehot_multi_chunk_table ); impl_multi_chunk_companion!( - D64OneHotMultiChunkW2R2, - D64OneHot, + OneHotMultiChunkW2R2, + OneHot, akita_types::MultiChunkProfileId::W2R2, - "schedules-fp128-d64-onehot-multi-chunk-w2r2", - fp128_d64_onehot_multi_chunk_w2r2_table + "schedules-fp128-onehot-multi-chunk-w2r2", + fp128_onehot_multi_chunk_w2r2_table ); impl_multi_chunk_companion!( - D64OneHotMultiChunkW4R2, - D64OneHot, + OneHotMultiChunkW4R2, + OneHot, akita_types::MultiChunkProfileId::W4R2, - "schedules-fp128-d64-onehot-multi-chunk-w4r2", - fp128_d64_onehot_multi_chunk_w4r2_table + "schedules-fp128-onehot-multi-chunk-w4r2", + fp128_onehot_multi_chunk_w4r2_table ); impl_multi_chunk_companion!( - D64DenseMultiChunk, - D64Dense, + DenseMultiChunk, + Dense, akita_types::MultiChunkProfileId::W8R2, - "schedules-fp128-d64-dense-multi-chunk", - fp128_d64_dense_multi_chunk_table + "schedules-fp128-dense-multi-chunk", + fp128_dense_multi_chunk_table ); - -/// Concrete fp128 preset selected by a schedule-family query. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Fp128Preset { - /// Dense adaptive `D=64` preset. - D64Dense, - /// Dense `D=128` preset (comparison / legacy; D64 is smaller under - /// committed-fold A-role pricing). - D128Dense, - /// Binary onehot generated `D=64` preset. - D64OneHot, - /// Binary onehot `D=128` preset (comparison / legacy; D64 is smaller under - /// committed-fold A-role pricing). - D128OneHot, -} - -impl Fp128Preset { - /// Ring dimension used by this preset. - pub const fn ring_dimension(self) -> usize { - match self { - Self::D64Dense | Self::D64OneHot => 64, - Self::D128Dense | Self::D128OneHot => 128, - } - } - - /// Whether this preset is onehot-oriented. - pub const fn is_onehot(self) -> bool { - matches!(self, Self::D64OneHot | Self::D128OneHot) - } - - /// Stable human-readable preset name. - pub const fn name(self) -> &'static str { - match self { - Self::D64Dense => "D64Dense", - Self::D128Dense => "D128Dense", - Self::D64OneHot => "D64OneHot", - Self::D128OneHot => "D128OneHot", - } - } -} - -/// Best generated schedule for one fp128 preset family. -#[derive(Clone, Debug)] -pub struct Fp128ScheduleSelection { - /// Selected concrete preset. - pub preset: Fp128Preset, - /// Runtime schedule selected for the supplied lookup key. - pub schedule: FoldSchedule, - /// Non-protocol planner estimate used to compare presets. - pub estimate: akita_types::FoldScheduleEstimate, -} - -fn candidate( - preset: Fp128Preset, - key: PolynomialGroupLayout, -) -> Result, AkitaError> { - let lookup_key = AkitaScheduleLookupKey::single(key); - let Some(catalog) = Cfg::schedule_catalog() else { - return Ok(None); - }; - let Some(entry) = akita_schedules::generated::table_entry(catalog, &lookup_key) else { - return Ok(None); - }; - let policy = crate::policy_of::(); - let estimate = akita_schedules::estimate_proof_bytes( - entry, - &lookup_key, - &policy, - Cfg::ring_challenge_config, - )?; - let schedule = Cfg::runtime_schedule(lookup_key)?; - Ok(Some(Fp128ScheduleSelection { - preset, - schedule, - estimate: akita_types::FoldScheduleEstimate { - estimated_root_direct_payload_bytes: estimate, - estimated_root_stage3_payload_bytes: 0, - estimated_recursive_direct_payload_bytes: Vec::new(), - estimated_recursive_stage3_payload_bytes: Vec::new(), - estimated_terminal_direct_payload_bytes: 0, - estimated_terminal_response_payload_bytes: 0, - estimated_num_setup_field_elements: 0, - first_direct_setup_field_len: None, - selected_offload_edges: 0, - }, - })) -} - -fn best_by_exact_bytes(candidates: I) -> Option -where - I: IntoIterator>, -{ - candidates.into_iter().flatten().min_by_key(|selection| { - ( - selection - .estimate - .estimated_proof_payload_bytes() - .unwrap_or(usize::MAX), - selection.preset.ring_dimension(), - ) - }) -} - -/// Select the best dense fp128 preset for a schedule lookup key. -/// -/// The key carries singleton and multi-group batch shape data, so -/// this helper can be used by profile tooling without manually comparing -/// typed preset schedule tables. A genuine planner failure propagates as an -/// error; supported keys yield a folded schedule for each candidate preset. -/// -/// # Errors -/// -/// Propagates a planner / runtime-schedule failure (invalid key shape, -/// witness overflow, or an uncovered SIS-floor width). -pub fn best_dense_schedule( - key: PolynomialGroupLayout, -) -> Result, AkitaError> { - Ok(best_by_exact_bytes([ - candidate::(Fp128Preset::D64Dense, key)?, - candidate::(Fp128Preset::D128Dense, key)?, - ])) -} - -/// Select the best onehot fp128 preset for a schedule lookup key. -/// -/// A genuine planner failure propagates as an error; for any valid key every -/// preset yields a schedule, so the best one is always returned. -/// -/// # Errors -/// -/// Propagates a planner / runtime-schedule failure (invalid key shape, -/// witness overflow, or an uncovered SIS-floor width). -pub fn best_onehot_schedule( - key: PolynomialGroupLayout, -) -> Result, AkitaError> { - Ok(best_by_exact_bytes([ - candidate::(Fp128Preset::D64OneHot, key)?, - candidate::(Fp128Preset::D128OneHot, key)?, - ])) -} diff --git a/crates/akita-config/src/proof_optimized/tests.rs b/crates/akita-config/src/proof_optimized/tests.rs index 4d1b0c1d9..07e86add5 100644 --- a/crates/akita-config/src/proof_optimized/tests.rs +++ b/crates/akita-config/src/proof_optimized/tests.rs @@ -14,7 +14,7 @@ use akita_types::{ntt_cache_requires_i16_tail, AkitaScheduleLookupKey, Polynomia #[cfg(feature = "schedules-default")] #[test] fn setup_levels_are_exactly_root_and_recursive_folds() { - let schedule = fp128::D64Dense::runtime_schedule(AkitaScheduleLookupKey::single( + let schedule = fp128::Dense::runtime_schedule(AkitaScheduleLookupKey::single( PolynomialGroupLayout::singleton(30), )) .expect("generated fp128 schedule"); @@ -29,7 +29,7 @@ fn setup_levels_are_exactly_root_and_recursive_folds() { #[cfg(feature = "schedules-default")] #[test] fn generated_schedule_has_explicit_terminal_inner_only_topology() { - let schedule = fp128::D64OneHot::runtime_schedule(AkitaScheduleLookupKey::single( + let schedule = fp128::OneHot::runtime_schedule(AkitaScheduleLookupKey::single( PolynomialGroupLayout::singleton(32), )) .expect("generated one-hot schedule"); @@ -48,7 +48,7 @@ fn generated_schedule_has_explicit_terminal_inner_only_topology() { #[cfg(feature = "schedules-default")] #[test] fn setup_capacity_includes_terminal_inner_matrix() { - let schedule = fp128::D64Dense::runtime_schedule(AkitaScheduleLookupKey::single( + let schedule = fp128::Dense::runtime_schedule(AkitaScheduleLookupKey::single( PolynomialGroupLayout::singleton(28), )) .expect("generated fp128 schedule"); @@ -117,14 +117,14 @@ fn generated_q32_terminals_require_the_i16_tail() { #[cfg(feature = "schedules-default")] #[test] -fn fp128_d128_onehot_catalog_freezes_root_fold_digits() { - let table = fp128::D128OneHot::schedule_catalog().expect("D128 one-hot schedule catalog"); +fn fp128_adaptive_onehot_catalog_freezes_root_fold_digits() { + let table = fp128::OneHot::schedule_catalog().expect("fp128 one-hot catalog"); let first = table .entries .first() - .expect("nonempty D128 one-hot catalog"); - let schedule = fp128::D128OneHot::runtime_schedule(first.to_runtime_lookup_key()) - .expect("resolve D128 one-hot row"); + .expect("nonempty adaptive one-hot catalog"); + let schedule = fp128::OneHot::runtime_schedule(first.to_runtime_lookup_key()) + .expect("resolve adaptive one-hot row"); let root = &schedule.root.params.final_group.commitment; assert_eq!( root.num_digits_fold, @@ -135,8 +135,7 @@ fn fp128_d128_onehot_catalog_freezes_root_fold_digits() { #[cfg(feature = "schedules-default")] #[test] fn setup_envelope_scan_includes_multi_polynomial_precommitted_groups() { - let layouts = - setup_capacity_scan_layouts::(14, 3).expect("setup scan layouts"); + let layouts = setup_capacity_scan_layouts::(14, 3).expect("setup scan layouts"); assert!(layouts.iter().any(|layout| { layout.groups() @@ -146,3 +145,21 @@ fn setup_envelope_scan_includes_multi_polynomial_precommitted_groups() { ] })); } + +#[cfg(feature = "schedules-default")] +#[test] +fn setup_capacity_includes_standalone_precommit_recipes() { + let profile = + crate::committed_group_profile::(&PolynomialGroupLayout::new(16, 1)) + .expect("dense precommit profile"); + let capacity = fp128::Dense::setup_matrix_capacity(16, 1).expect("dense setup capacity"); + let a_fields = profile.inner_commit_matrix.output_rank() + * profile.inner_commit_matrix.input_width() + * profile.inner_commit_matrix.ring_dimension(); + let b_fields = profile.outer_commit_matrix.output_rank() + * profile.outer_commit_matrix.input_width() + * profile.outer_commit_matrix.ring_dimension(); + + assert!(capacity.num_field_elements >= a_fields); + assert!(capacity.num_field_elements >= b_fields); +} diff --git a/crates/akita-config/src/recursive_commitment.rs b/crates/akita-config/src/recursive_commitment.rs index d7e0acd46..5dbc91d30 100644 --- a/crates/akita-config/src/recursive_commitment.rs +++ b/crates/akita-config/src/recursive_commitment.rs @@ -4,12 +4,12 @@ use crate::CommitmentConfig; use akita_challenges::SparseChallengeConfig; use akita_field::AkitaError; use akita_types::{ - ChunkedWitnessCfg, CommitmentRingDims, DecompositionParams, FoldSchedule, OpeningClaimsLayout, - SetupMatrixCapacity, SisModulusProfileId, + ChunkedWitnessCfg, DecompositionParams, FoldSchedule, OpeningClaimsLayout, SetupMatrixCapacity, + SisModulusProfileId, }; #[cfg(any( - feature = "schedules-fp128-d64-onehot-recursive", - feature = "schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2" + feature = "schedules-fp128-onehot-recursive", + feature = "schedules-fp128-onehot-recursive-multi-chunk-w8r2" ))] use std::any::TypeId; use std::marker::PhantomData; @@ -23,7 +23,8 @@ impl CommitmentConfig for RecursiveCommitmentConfig type ExtField = Cfg::ExtField; const D: usize = Cfg::D; - const RING_DIMENSION_CANDIDATES: &'static [CommitmentRingDims] = Cfg::RING_DIMENSION_CANDIDATES; + const RING_DIMENSION_SCHEDULE_MODE: akita_schedules::RingDimensionScheduleMode = + Cfg::RING_DIMENSION_SCHEDULE_MODE; fn decomposition() -> DecompositionParams { Cfg::decomposition() @@ -68,18 +69,18 @@ impl CommitmentConfig for RecursiveCommitmentConfig } fn schedule_catalog() -> Option { - #[cfg(feature = "schedules-fp128-d64-onehot-recursive")] + #[cfg(feature = "schedules-fp128-onehot-recursive")] { - if TypeId::of::() == TypeId::of::() { - return Some(akita_schedules::fp128_d64_onehot_recursive_table()); + if TypeId::of::() == TypeId::of::() { + return Some(akita_schedules::fp128_onehot_recursive_table()); } } - #[cfg(feature = "schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2")] + #[cfg(feature = "schedules-fp128-onehot-recursive-multi-chunk-w8r2")] { if TypeId::of::() - == TypeId::of::() + == TypeId::of::() { - return Some(akita_schedules::fp128_d64_onehot_recursive_multi_chunk_w8r2_table()); + return Some(akita_schedules::fp128_onehot_recursive_multi_chunk_w8r2_table()); } } None @@ -108,58 +109,47 @@ impl CommitmentConfig for RecursiveCommitmentConfig #[cfg(all( test, - feature = "schedules-fp128-d64-onehot", - feature = "schedules-fp128-d64-onehot-recursive" + any( + feature = "schedules-fp128-onehot-recursive", + feature = "schedules-fp128-onehot-recursive-multi-chunk-w8r2" + ) ))] -mod tests { +mod adaptive_precommit_tests { use super::*; use crate::proof_optimized::fp128; use crate::PrecommittedCommitmentConfig; - use akita_field::Prime128OffsetA7F7; - use akita_types::{ - r_decomp_levels, shared_setup_fold_gadget, AkitaScheduleLookupKey, CommittedGroupProfile, - PolynomialGroupLayout, PreparedRelationAddress, RelationAddressGeometry, - SetupContributionGroupInputs, SetupContributionPlan, WitnessLayout, - }; + use akita_types::OpeningClaimsLayout; - fn scalar(value: u128) -> Prime128OffsetA7F7 { - Prime128OffsetA7F7::from_canonical_u128(value) + fn assert_nv16_precommit() { + let layout = OpeningClaimsLayout::new(16, 1).expect("precommit layout"); + PrecommittedCommitmentConfig::>:: + get_params_for_batched_commitment(&layout) + .expect("adaptive recursive catalog must expose its base precommit profile"); } - fn eq_at_index(point: &[Prime128OffsetA7F7], index: usize) -> Prime128OffsetA7F7 { - point.iter().copied().enumerate().fold( - Prime128OffsetA7F7::one(), - |weight, (bit, challenge)| { - if (index >> bit) & 1 == 1 { - weight * challenge - } else { - weight * (Prime128OffsetA7F7::one() - challenge) - } - }, - ) + #[cfg(feature = "schedules-fp128-onehot-recursive")] + #[test] + fn onehot_recursive_catalog_exposes_base_precommit_profiles() { + assert_nv16_precommit::(); } - fn profiling_schedule() -> (FoldSchedule, OpeningClaimsLayout) { - type Cfg = RecursiveCommitmentConfig; - - let precommitted = PolynomialGroupLayout::new(16, 1); - let singleton = OpeningClaimsLayout::new(16, 1).expect("singleton precommit layout"); - let params = - PrecommittedCommitmentConfig::::get_params_for_batched_commitment(&singleton) - .expect("recursive-catalog precommit params"); - let descriptor = CommittedGroupProfile::from_params(precommitted, ¶ms); - let key = AkitaScheduleLookupKey { - final_group: PolynomialGroupLayout::new(32, 2), - precommitteds: vec![descriptor, descriptor], - }; - let layout = key.opening_layout().expect("profile opening layout"); - let schedule = Cfg::runtime_schedule(key).expect("recursive profile schedule"); - (schedule, layout) + #[cfg(feature = "schedules-fp128-onehot-recursive-multi-chunk-w8r2")] + #[test] + fn onehot_recursive_w8r2_catalog_exposes_base_precommit_profiles() { + assert_nv16_precommit::(); } +} + +#[cfg(all(test, feature = "schedules-fp128-onehot-recursive"))] +mod tests { + use super::*; + use crate::proof_optimized::fp128; + use crate::PrecommittedCommitmentConfig; + use akita_types::{AkitaScheduleLookupKey, CommittedGroupProfile, PolynomialGroupLayout}; #[test] fn prove_layout_uses_the_recursive_catalogs_frozen_precommit_params() { - type Cfg = RecursiveCommitmentConfig; + type Cfg = RecursiveCommitmentConfig; let precommitted = PolynomialGroupLayout::new(16, 1); let final_group = PolynomialGroupLayout::new(32, 2); @@ -182,85 +172,4 @@ mod tests { .iter() .all(|group| group.descriptor == expected)); } - - #[test] - fn profiling_schedule_tensor_setup_weights_match_dense_materialization() { - let (schedule, opening_batch) = profiling_schedule(); - let params = &schedule.root.params.final_group.commitment; - let witness_layout = WitnessLayout::new( - params, - &opening_batch, - params.witness_chunk.num_chunks, - r_decomp_levels::(params.log_basis_open), - ) - .expect("root witness layout"); - let rows = witness_layout.r_rows().len(); - let order = opening_batch.root_group_order().expect("relation order"); - let groups = order - .iter() - .map(|&group_id| { - let group_params = params - .group_params(&opening_batch, group_id) - .expect("group params"); - let group_layout = opening_batch.group_layout(group_id).expect("group layout"); - SetupContributionGroupInputs { - group_id, - num_claims: group_layout.num_polynomials(), - depth_fold: group_params.num_digits_fold(), - a_row_start: params - .a_row_range(&opening_batch, group_id) - .expect("A rows") - .start, - b_row_start: params - .commitment_row_range(&opening_batch, group_id) - .expect("B rows") - .start, - } - }) - .collect::>(); - let next_d = schedule.recursive_folds[0].params.witness.d_a(); - let address_geometry = RelationAddressGeometry::new( - params.role_dims(), - next_d, - witness_layout.live_coeff_len(), - ) - .expect("relation address geometry"); - let address_point = (0..address_geometry.relation_lane_variable_count()) - .map(|index| scalar(101 + index as u128)) - .collect::>(); - let eq_tau1 = (0..rows) - .map(|index| scalar(211 + index as u128)) - .collect::>(); - let alpha = scalar(3); - let fold_gadget = - shared_setup_fold_gadget::(params, &opening_batch, &groups); - let plan = SetupContributionPlan::prepare::( - params, - &opening_batch, - eq_tau1.into(), - &witness_layout, - &groups, - PreparedRelationAddress::new(&address_point).expect("relation address"), - fold_gadget.as_deref(), - address_geometry, - ) - .expect("setup tensor plan"); - let setup_idx_bits = plan.required().next_power_of_two().trailing_zeros() as usize; - let rho = (0..setup_idx_bits) - .map(|index| scalar(401 + index as u128)) - .collect::>(); - let dense_mle = plan - .materialize_setup_index_weights(alpha) - .expect("dense setup weights") - .into_iter() - .enumerate() - .fold(Prime128OffsetA7F7::zero(), |acc, (index, weight)| { - acc + eq_at_index(&rho, index) * weight - }); - assert_eq!( - plan.evaluate_setup_index_weight_mle(&rho, alpha) - .expect("tensor setup weight MLE"), - dense_mle - ); - } } diff --git a/crates/akita-config/src/setup_prefix_slots.rs b/crates/akita-config/src/setup_prefix_slots.rs index e7416ab9c..30ec48c44 100644 --- a/crates/akita-config/src/setup_prefix_slots.rs +++ b/crates/akita-config/src/setup_prefix_slots.rs @@ -149,7 +149,7 @@ pub(crate) fn recursive_group_batch_candidates_for_capacity; + type SetupCfg = RecursiveCommitmentConfig; fn profiling_recursive_key() -> AkitaScheduleLookupKey { let pre = PolynomialGroupLayout::new(16, 1); @@ -266,10 +266,14 @@ mod tests { .expect("slot ids"); assert!(!ids.is_empty()); for slot_id in &ids { - assert_eq!(slot_id.d_setup(), 64); assert!(slot_id.natural_len > 0); assert!(slot_id.n_prefix().expect("n_prefix") >= slot_id.natural_len); } + let dimensions = ids + .iter() + .map(SetupPrefixSlotId::d_setup) + .collect::>(); + assert_eq!(dimensions, BTreeSet::from([64, 256])); let unique: BTreeSet<_> = ids.iter().cloned().collect(); assert_eq!(unique.len(), ids.len()); } diff --git a/crates/akita-config/tests/basis_envelope.rs b/crates/akita-config/tests/basis_envelope.rs index 12b5dbf53..427e95c99 100644 --- a/crates/akita-config/tests/basis_envelope.rs +++ b/crates/akita-config/tests/basis_envelope.rs @@ -1,4 +1,4 @@ -//! Planner guard: shipped `fp128::D64OneHot` schedules must stay within the +//! Planner guard: shipped adaptive fp128 one-hot schedules must stay within the //! configured proof-optimized basis search window. use akita_config::proof_optimized::fp128; @@ -9,8 +9,8 @@ use akita_types::{AkitaScheduleLookupKey, PolynomialGroupLayout}; const BASIS_ENVELOPE_NUM_VARS: &[usize] = &[10, 16, 28, 30, 64, 120]; #[test] -fn d64_onehot_schedule_stays_within_basis_envelope() { - type Cfg = fp128::D64OneHot; +fn adaptive_onehot_schedule_stays_within_basis_envelope() { + type Cfg = fp128::OneHot; for &nv in BASIS_ENVELOPE_NUM_VARS { let schedule = match Cfg::runtime_schedule(AkitaScheduleLookupKey::single( diff --git a/crates/akita-config/tests/generated_tables.rs b/crates/akita-config/tests/generated_tables.rs index c6e5ff115..e3d917444 100644 --- a/crates/akita-config/tests/generated_tables.rs +++ b/crates/akita-config/tests/generated_tables.rs @@ -42,8 +42,7 @@ use akita_planner::generated_families::{ emitted_scalar_keys, GeneratedFamily, ALL_GENERATED_FAMILIES, }; use akita_types::{ - sis::HonestFoldPolicySpec, AkitaScheduleLookupKey, CommitmentRingDims, FoldSchedule, - PolynomialGroupLayout, + sis::HonestFoldPolicySpec, AkitaScheduleLookupKey, FoldSchedule, PolynomialGroupLayout, }; type GroupBatchCandidate = (AkitaScheduleLookupKey, Vec); @@ -71,28 +70,24 @@ fn group_batch_emission_matches_supported_policy_shape() { fn family_catalog_is_linked(family: &GeneratedFamily) -> bool { match family.module_name { - "fp128_d128_dense" => fp128::D128Dense::schedule_catalog().is_some(), - "fp128_d128_onehot" => fp128::D128OneHot::schedule_catalog().is_some(), - "fp128_d256_onehot" => fp128::D256OneHot::schedule_catalog().is_some(), - "fp128_mixed_dim_onehot" => fp128::MixedDimFp128OneHot::schedule_catalog().is_some(), - "fp128_d64_onehot" => fp128::D64OneHot::schedule_catalog().is_some(), - "fp128_d64_onehot_recursive" => { - as CommitmentConfig>::schedule_catalog() + "fp128_onehot" => fp128::OneHot::schedule_catalog().is_some(), + "fp128_dense" => fp128::Dense::schedule_catalog().is_some(), + "fp128_onehot_recursive" => { + as CommitmentConfig>::schedule_catalog() .is_some() } - "fp128_d64_onehot_recursive_multi_chunk_w8r2" => { - as CommitmentConfig>::schedule_catalog() + "fp128_onehot_recursive_multi_chunk_w8r2" => { + as CommitmentConfig>::schedule_catalog() .is_some() } - "fp128_d64_dense" => fp128::D64Dense::schedule_catalog().is_some(), - "fp128_d64_onehot_multi_chunk" => fp128::D64OneHotMultiChunk::schedule_catalog().is_some(), - "fp128_d64_onehot_multi_chunk_w2r2" => { - fp128::D64OneHotMultiChunkW2R2::schedule_catalog().is_some() + "fp128_onehot_multi_chunk" => fp128::OneHotMultiChunk::schedule_catalog().is_some(), + "fp128_onehot_multi_chunk_w2r2" => { + fp128::OneHotMultiChunkW2R2::schedule_catalog().is_some() } - "fp128_d64_onehot_multi_chunk_w4r2" => { - fp128::D64OneHotMultiChunkW4R2::schedule_catalog().is_some() + "fp128_onehot_multi_chunk_w4r2" => { + fp128::OneHotMultiChunkW4R2::schedule_catalog().is_some() } - "fp128_d64_dense_multi_chunk" => fp128::D64DenseMultiChunk::schedule_catalog().is_some(), + "fp128_dense_multi_chunk" => fp128::DenseMultiChunk::schedule_catalog().is_some(), "fp64_d128_dense" => fp64::D128Dense::schedule_catalog().is_some(), "fp64_d128_onehot" => fp64::D128OneHot::schedule_catalog().is_some(), "fp64_d256_onehot" => fp64::D256OneHot::schedule_catalog().is_some(), @@ -205,12 +200,12 @@ fn assert_precommit_registry( #[cfg(feature = "all-schedules")] #[test] fn catalog_identity_rejects_non_v1_protocol_epoch() { - let mut catalog = fp128::D64Dense::schedule_catalog().expect("generated catalog"); + let mut catalog = fp128::Dense::schedule_catalog().expect("generated catalog"); catalog.identity.protocol_epoch -= 1; let error = validate_catalog_identity( &catalog, - &policy_of::(), - fp128::D64Dense::ring_challenge_config, + &policy_of::(), + fp128::Dense::ring_challenge_config, ) .expect_err("non-v1 protocol epoch must not validate"); assert!(error.to_string().contains("catalog identity mismatch")); @@ -219,11 +214,11 @@ fn catalog_identity_rejects_non_v1_protocol_epoch() { #[cfg(feature = "all-schedules")] #[test] fn catalog_identity_rejects_planner_policy_changes() { - let policy = policy_of::(); - let catalog = fp128::D64Dense::schedule_catalog().expect("generated catalog"); + let policy = policy_of::(); + let catalog = fp128::Dense::schedule_catalog().expect("generated catalog"); let assert_rejected = |label: &str, mutated: akita_schedules::GeneratedScheduleTable| { let error = - validate_catalog_identity(&mutated, &policy, fp128::D64Dense::ring_challenge_config) + validate_catalog_identity(&mutated, &policy, fp128::Dense::ring_challenge_config) .expect_err("planner-policy mismatch must not validate"); assert!( error.to_string().contains("catalog identity mismatch"), @@ -248,7 +243,7 @@ fn catalog_identity_rejects_planner_policy_changes() { #[cfg(feature = "all-schedules")] #[test] fn equal_lookup_keys_form_one_contiguous_candidate_range() { - let catalog = fp128::D64Dense::schedule_catalog().expect("generated catalog"); + let catalog = fp128::Dense::schedule_catalog().expect("generated catalog"); let entry = *catalog.entries.first().expect("nonempty generated catalog"); let entries = Box::leak(vec![entry, entry].into_boxed_slice()); let duplicate_table = akita_schedules::GeneratedScheduleTable { @@ -265,39 +260,32 @@ fn equal_lookup_keys_form_one_contiguous_candidate_range() { #[cfg(feature = "all-schedules")] #[test] -fn mixed_catalog_identity_binds_nonwinning_candidate_tuples() { - static WITHOUT_NONWINNER: &[CommitmentRingDims] = &[ - CommitmentRingDims::uniform(64), - CommitmentRingDims { - inner: 128, - outer: 64, - opening: 64, - }, - CommitmentRingDims { - inner: 256, - outer: 128, - opening: 128, - }, - ]; - - let policy = policy_of::(); - let catalog = fp128::MixedDimFp128OneHot::schedule_catalog().expect("mixed catalog"); - assert!(catalog.entries.iter().all(|entry| entry - .root - .final_group - .commitment - .inner_commit_matrix - .ring_dimension - != 128)); +fn mixed_catalog_identity_binds_candidate_dimensions() { + static WITHOUT_NONWINNER: &[usize] = &[64, 256]; + let policy = policy_of::(); + let catalog = fp128::OneHot::schedule_catalog().expect("fp128 one-hot catalog"); let mut mutated = catalog; - mutated.identity.ring_dimension_candidates = WITHOUT_NONWINNER; - let error = validate_catalog_identity( - &mutated, - &policy, - fp128::MixedDimFp128OneHot::ring_challenge_config, - ) - .expect_err("removing an admitted nonwinner must invalidate the catalog"); + let akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_b_dimensions, + potential_d_dimensions, + .. + } = mutated.identity.ring_dimension_schedule_mode + else { + panic!("mixed catalog must use adaptive dimensions"); + }; + mutated.identity.ring_dimension_schedule_mode = + akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions: WITHOUT_NONWINNER, + potential_b_dimensions, + potential_d_dimensions, + }; + let error = validate_catalog_identity(&mutated, &policy, fp128::OneHot::ring_challenge_config) + .expect_err("removing an admitted nonwinner must invalidate the catalog"); assert!(error.to_string().contains("catalog identity mismatch")); } @@ -326,32 +314,24 @@ fn family_catalog( keys: &[PolynomialGroupLayout], ) -> akita_schedules::GeneratedScheduleTable { match family.module_name { - "fp128_d128_dense" => prepare_family_catalog::(family, keys), - "fp128_d128_onehot" => prepare_family_catalog::(family, keys), - "fp128_d256_onehot" => prepare_family_catalog::(family, keys), - "fp128_mixed_dim_onehot" => { - prepare_family_catalog::(family, keys) - } - "fp128_d64_onehot" => prepare_family_catalog::(family, keys), - "fp128_d64_onehot_recursive" => prepare_family_catalog::< - akita_config::RecursiveCommitmentConfig, + "fp128_onehot" => prepare_family_catalog::(family, keys), + "fp128_dense" => prepare_family_catalog::(family, keys), + "fp128_onehot_recursive" => prepare_family_catalog::< + akita_config::RecursiveCommitmentConfig, >(family, keys), - "fp128_d64_onehot_recursive_multi_chunk_w8r2" => prepare_family_catalog::< - akita_config::RecursiveCommitmentConfig, + "fp128_onehot_recursive_multi_chunk_w8r2" => prepare_family_catalog::< + akita_config::RecursiveCommitmentConfig, >(family, keys), - "fp128_d64_dense" => prepare_family_catalog::(family, keys), - "fp128_d64_onehot_multi_chunk" => { - prepare_family_catalog::(family, keys) - } - "fp128_d64_onehot_multi_chunk_w2r2" => { - prepare_family_catalog::(family, keys) + "fp128_onehot_multi_chunk" => { + prepare_family_catalog::(family, keys) } - "fp128_d64_onehot_multi_chunk_w4r2" => { - prepare_family_catalog::(family, keys) + "fp128_onehot_multi_chunk_w2r2" => { + prepare_family_catalog::(family, keys) } - "fp128_d64_dense_multi_chunk" => { - prepare_family_catalog::(family, keys) + "fp128_onehot_multi_chunk_w4r2" => { + prepare_family_catalog::(family, keys) } + "fp128_dense_multi_chunk" => prepare_family_catalog::(family, keys), "fp64_d128_dense" => prepare_family_catalog::(family, keys), "fp64_d128_onehot" => prepare_family_catalog::(family, keys), "fp64_d256_onehot" => prepare_family_catalog::(family, keys), @@ -385,45 +365,29 @@ fn assert_group_batch_table_hits( fn assert_family_group_batch_table_hit(family: &GeneratedFamily, requests: &[GroupBatchCandidate]) { match family.module_name { - "fp128_d128_dense" => { - assert_group_batch_table_hits::(family.module_name, requests) + "fp128_onehot" => { + assert_group_batch_table_hits::(family.module_name, requests) } - "fp128_d128_onehot" => { - assert_group_batch_table_hits::(family.module_name, requests) + "fp128_dense" => { + assert_group_batch_table_hits::(family.module_name, requests) } - "fp128_d256_onehot" => { - assert_group_batch_table_hits::(family.module_name, requests) - } - "fp128_mixed_dim_onehot" => assert_group_batch_table_hits::( - family.module_name, - requests, - ), - "fp128_d64_onehot" => { - assert_group_batch_table_hits::(family.module_name, requests) - } - "fp128_d64_onehot_recursive" => assert_group_batch_table_hits::< - akita_config::RecursiveCommitmentConfig, + "fp128_onehot_recursive" => assert_group_batch_table_hits::< + akita_config::RecursiveCommitmentConfig, >(family.module_name, requests), - "fp128_d64_onehot_recursive_multi_chunk_w8r2" => assert_group_batch_table_hits::< - akita_config::RecursiveCommitmentConfig, + "fp128_onehot_recursive_multi_chunk_w8r2" => assert_group_batch_table_hits::< + akita_config::RecursiveCommitmentConfig, >(family.module_name, requests), - "fp128_d64_dense" => { - assert_group_batch_table_hits::(family.module_name, requests) + "fp128_onehot_multi_chunk" => { + assert_group_batch_table_hits::(family.module_name, requests) } - "fp128_d64_onehot_multi_chunk" => { - assert_group_batch_table_hits::( - family.module_name, - requests, - ) - } - "fp128_d64_onehot_multi_chunk_w2r2" => assert_group_batch_table_hits::< - fp128::D64OneHotMultiChunkW2R2, + "fp128_onehot_multi_chunk_w2r2" => assert_group_batch_table_hits::< + fp128::OneHotMultiChunkW2R2, >(family.module_name, requests), - "fp128_d64_onehot_multi_chunk_w4r2" => assert_group_batch_table_hits::< - fp128::D64OneHotMultiChunkW4R2, + "fp128_onehot_multi_chunk_w4r2" => assert_group_batch_table_hits::< + fp128::OneHotMultiChunkW4R2, >(family.module_name, requests), - "fp128_d64_dense_multi_chunk" => { - assert_group_batch_table_hits::(family.module_name, requests) + "fp128_dense_multi_chunk" => { + assert_group_batch_table_hits::(family.module_name, requests) } "fp64_d128_dense" => { assert_group_batch_table_hits::(family.module_name, requests) @@ -483,31 +447,25 @@ fn resolve_family_group_batch_schedule( request: &GroupBatchCandidate, ) -> Result { match family.module_name { - "fp128_d128_dense" => table_backed_group_batch_schedule::(request), - "fp128_d128_onehot" => table_backed_group_batch_schedule::(request), - "fp128_d256_onehot" => table_backed_group_batch_schedule::(request), - "fp128_mixed_dim_onehot" => { - table_backed_group_batch_schedule::(request) - } - "fp128_d64_onehot" => table_backed_group_batch_schedule::(request), - "fp128_d64_onehot_recursive" => table_backed_group_batch_schedule::< - akita_config::RecursiveCommitmentConfig, + "fp128_onehot" => table_backed_group_batch_schedule::(request), + "fp128_dense" => table_backed_group_batch_schedule::(request), + "fp128_onehot_recursive" => table_backed_group_batch_schedule::< + akita_config::RecursiveCommitmentConfig, >(request), - "fp128_d64_onehot_recursive_multi_chunk_w8r2" => table_backed_group_batch_schedule::< - akita_config::RecursiveCommitmentConfig, + "fp128_onehot_recursive_multi_chunk_w8r2" => table_backed_group_batch_schedule::< + akita_config::RecursiveCommitmentConfig, >(request), - "fp128_d64_dense" => table_backed_group_batch_schedule::(request), - "fp128_d64_onehot_multi_chunk" => { - table_backed_group_batch_schedule::(request) + "fp128_onehot_multi_chunk" => { + table_backed_group_batch_schedule::(request) } - "fp128_d64_onehot_multi_chunk_w2r2" => { - table_backed_group_batch_schedule::(request) + "fp128_onehot_multi_chunk_w2r2" => { + table_backed_group_batch_schedule::(request) } - "fp128_d64_onehot_multi_chunk_w4r2" => { - table_backed_group_batch_schedule::(request) + "fp128_onehot_multi_chunk_w4r2" => { + table_backed_group_batch_schedule::(request) } - "fp128_d64_dense_multi_chunk" => { - table_backed_group_batch_schedule::(request) + "fp128_dense_multi_chunk" => { + table_backed_group_batch_schedule::(request) } "fp64_d128_dense" => table_backed_group_batch_schedule::(request), "fp64_d128_onehot" => table_backed_group_batch_schedule::(request), diff --git a/crates/akita-config/tests/runtime_fallback.rs b/crates/akita-config/tests/runtime_fallback.rs index 26179e1e7..fdd9cf21a 100644 --- a/crates/akita-config/tests/runtime_fallback.rs +++ b/crates/akita-config/tests/runtime_fallback.rs @@ -22,7 +22,8 @@ use akita_schedules::{ PlannerPolicy, ResolvedScheduleRow, }; use akita_types::{ - AkitaScheduleLookupKey, CommittedGroupProfile, OpeningClaimsLayout, PolynomialGroupLayout, + AkitaScheduleLookupKey, CommitmentRingDims, CommittedGroupProfile, OpeningClaimsLayout, + PolynomialGroupLayout, }; /// A one-point 3-poly key that no generated table carries (generated tables only @@ -84,14 +85,14 @@ fn check_table_miss_rejection(num_vars: usize) { #[test] fn catalog_miss_rejects_non_shipped_keys() { - check_table_miss_rejection::(14); - check_table_miss_rejection::(16); + check_table_miss_rejection::(27); + check_table_miss_rejection::(27); check_table_miss_rejection::(16); } #[test] fn fixed_width_selection_resolves_the_same_exact_generated_row() { - type Cfg = fp128::D64Dense; + type Cfg = fp128::Dense; let catalog = Cfg::schedule_catalog().expect("dense schedule catalog"); let entry = catalog.entries.first().expect("nonempty generated catalog"); @@ -133,7 +134,7 @@ fn fixed_width_selection_resolves_the_same_exact_generated_row() { #[test] fn cached_catalog_rows_do_not_bypass_runtime_hook_validation() { - type Cfg = fp128::D64Dense; + type Cfg = fp128::Dense; let catalog = Cfg::schedule_catalog().expect("dense schedule catalog"); let entry = catalog.entries.first().expect("nonempty generated catalog"); @@ -183,7 +184,7 @@ fn assert_mutated_row_is_rejected( #[test] fn resolved_row_audit_rejects_low_rank_root_d_and_terminal_a() { - type Cfg = fp128::D64Dense; + type Cfg = fp128::Dense; let catalog = Cfg::schedule_catalog().expect("dense schedule catalog"); let entry = catalog.entries.first().expect("nonempty generated catalog"); @@ -243,7 +244,7 @@ fn resolved_row_audit_rejects_low_rank_root_d_and_terminal_a() { #[test] fn resolved_row_audit_rejects_each_noncanonical_terminal_shape_field() { - type Cfg = fp128::D64Dense; + type Cfg = fp128::Dense; let catalog = Cfg::schedule_catalog().expect("dense schedule catalog"); let entry = catalog.entries.first().expect("nonempty generated catalog"); @@ -288,25 +289,36 @@ fn resolved_row_audit_rejects_each_noncanonical_terminal_shape_field() { } #[test] -fn recursive_adapter_delegates_scalar_keys_to_the_ordinary_catalog() { - let key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::singleton(18)); - let ordinary = fp128::D64OneHot::runtime_schedule(key.clone()) - .expect("ordinary scalar schedule must resolve"); - let recursive = RecursiveCommitmentConfig::::runtime_schedule(key) - .expect("recursive adapter scalar schedule must resolve"); - assert_schedule_eq("recursive scalar delegation", &ordinary, &recursive); +fn grouped_recursive_catalog_rejects_without_recursive_feature() { + let precommitted_group = PolynomialGroupLayout::singleton(16); + let precommitted_params = + fp128::OneHot::runtime_schedule(AkitaScheduleLookupKey::single(precommitted_group)) + .expect("base OneHot precommit schedule") + .root + .params + .final_group + .commitment; + let descriptor = CommittedGroupProfile::from_params(precommitted_group, &precommitted_params); + let key = AkitaScheduleLookupKey { + final_group: PolynomialGroupLayout::new(32, 2), + precommitteds: vec![descriptor, descriptor], + }; + assert!(matches!( + RecursiveCommitmentConfig::::runtime_schedule(key), + Err(akita_field::AkitaError::UnsupportedSchedule(_)) + )); } #[test] fn adapters_forward_mixed_dimension_policy() { - type Base = fp128::MixedDimFp128OneHot; + type Base = fp128::OneHot; assert_eq!( - as CommitmentConfig>::RING_DIMENSION_CANDIDATES, - Base::RING_DIMENSION_CANDIDATES, + as CommitmentConfig>::RING_DIMENSION_SCHEDULE_MODE, + Base::RING_DIMENSION_SCHEDULE_MODE, ); assert_eq!( - as CommitmentConfig>::RING_DIMENSION_CANDIDATES, - Base::RING_DIMENSION_CANDIDATES, + as CommitmentConfig>::RING_DIMENSION_SCHEDULE_MODE, + Base::RING_DIMENSION_SCHEDULE_MODE, ); assert_eq!( as CommitmentConfig>::selection_policy(), @@ -327,7 +339,7 @@ fn assert_policy_matches_cfg() { min_offloaded_witness_contraction: 3, uniform_ring_dimension: Cfg::D, setup_prefix_inner_ring_dimension: Cfg::setup_prefix_inner_ring_dimension(), - ring_dimension_candidates: Cfg::RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: Cfg::RING_DIMENSION_SCHEDULE_MODE, decomposition: Cfg::decomposition(), sis_modulus_profile: Cfg::sis_modulus_profile(), sis_security_policy: akita_types::DEFAULT_SIS_SECURITY_POLICY, @@ -347,7 +359,7 @@ fn assert_policy_matches_cfg() { #[test] fn runtime_rejects_malformed_extension_geometry_without_panicking() { - type Cfg = fp128::D64OneHot; + type Cfg = fp128::OneHot; let catalog = Cfg::schedule_catalog(); let key = PolynomialGroupLayout::singleton(14); let reject = |mutate: fn(&mut PlannerPolicy)| { @@ -374,16 +386,14 @@ fn runtime_rejects_malformed_extension_geometry_without_panicking() { #[test] fn policy_bridge_matches_cfg_hooks() { - assert_policy_matches_cfg::(); - assert_policy_matches_cfg::(); - assert_policy_matches_cfg::(); - assert_policy_matches_cfg::(); + assert_policy_matches_cfg::(); + assert_policy_matches_cfg::(); assert_policy_matches_cfg::(); } #[test] -fn offline_planner_admits_dense_multi_group_roots() { - type Cfg = fp128::D64Dense; +fn adaptive_dense_plans_multi_group_roots_at_uniform_suffix_dimension() { + type Cfg = fp128::Dense; const PRE_NV: usize = 16; const FINAL_NV: usize = 20; @@ -406,21 +416,30 @@ fn offline_planner_admits_dense_multi_group_roots() { &policy_of::(), Cfg::ring_challenge_config, ) - .expect("dense multi-group schedule"); - - assert_eq!( - planned.schedule.root.params.precommitted_groups.len(), - key.precommitteds.len() - ); + .expect("adaptive dense grouped schedule"); planned .schedule .validate_structure() - .expect("dense grouped schedule structure"); + .expect("valid grouped schedule"); + assert_eq!( + planned + .schedule + .root + .params + .final_group + .commitment + .role_dims(), + CommitmentRingDims::uniform(64) + ); + assert_eq!( + planned.schedule.root.params.precommitted_groups[0].descriptor, + key.precommitteds[0] + ); } #[test] fn root_basis_is_derived_from_existing_policy_inputs() { - let fp128 = policy_of::(); + let fp128 = policy_of::(); assert_eq!(fp128.basis_range, (3, 6)); assert_eq!(fp128.decomposition.log_basis, 3); assert_eq!(fp128.log_basis_search_range_at_level(0), (3, 3)); @@ -445,10 +464,9 @@ fn runtime_schedule_never_panics_on_bounded_adversarial_keys() { ]; for key in adversarial { // Must return without panicking; either branch (Ok/Err) is fine. - let _ = fp128::D64OneHot::runtime_schedule(AkitaScheduleLookupKey::single(key)); + let _ = fp128::OneHot::runtime_schedule(AkitaScheduleLookupKey::single(key)); } } - fn committed_descriptor( group: PolynomialGroupLayout, ) -> CommittedGroupProfile { @@ -459,9 +477,9 @@ fn committed_descriptor( #[test] fn heterogeneous_group_profiles_match_generated_lookup_and_reject_unlisted_order() { - type Cfg = fp128::D64OneHot; + type Cfg = fp128::OneHot; let onehot_16 = committed_descriptor::(PolynomialGroupLayout::new(14, 1)); - let dense = committed_descriptor::(PolynomialGroupLayout::new(15, 2)); + let dense = committed_descriptor::(PolynomialGroupLayout::new(15, 2)); let key = AkitaScheduleLookupKey { final_group: PolynomialGroupLayout::new(16, 1), precommitteds: vec![onehot_16, dense], diff --git a/crates/akita-config/tests/schedule_catalog_feature_off.rs b/crates/akita-config/tests/schedule_catalog_feature_off.rs index d2f7fa7db..3c2647382 100644 --- a/crates/akita-config/tests/schedule_catalog_feature_off.rs +++ b/crates/akita-config/tests/schedule_catalog_feature_off.rs @@ -8,18 +8,18 @@ use akita_types::{AkitaScheduleLookupKey, PolynomialGroupLayout}; #[test] fn schedule_catalog_none_without_feature_rejects() { - if cfg!(feature = "schedules-fp128-d64-onehot") { + if cfg!(feature = "schedules-fp128-onehot") { return; } assert!( - fp128::D64OneHot::schedule_catalog().is_none(), + fp128::OneHot::schedule_catalog().is_none(), "schedule feature disabled: schedule_catalog must be None" ); - let key = PolynomialGroupLayout::new(28, 1); + let key = PolynomialGroupLayout::new(32, 1); - let err = fp128::D64OneHot::runtime_schedule(AkitaScheduleLookupKey::single(key)) + let err = fp128::OneHot::runtime_schedule(AkitaScheduleLookupKey::single(key)) .expect_err("runtime schedule must reject without an enabled catalog"); assert!( matches!(err, akita_field::AkitaError::UnsupportedSchedule(_)), diff --git a/crates/akita-config/tests/schedule_catalog_miswire.rs b/crates/akita-config/tests/schedule_catalog_miswire.rs index 468255114..00c1eb3aa 100644 --- a/crates/akita-config/tests/schedule_catalog_miswire.rs +++ b/crates/akita-config/tests/schedule_catalog_miswire.rs @@ -9,16 +9,16 @@ use akita_types::PolynomialGroupLayout; #[test] fn miswired_catalog_rejects_before_lookup() { - let wrong_catalog = akita_schedules::fp128_d64_onehot_table(); + let wrong_catalog = akita_schedules::fp128_onehot_table(); let key = PolynomialGroupLayout::new(28, 1); let err = resolve_schedule( key, - &policy_of::(), - fp128::D64Dense::ring_challenge_config, + &policy_of::(), + fp128::Dense::ring_challenge_config, Some(wrong_catalog), ) - .expect_err("D64 dense preset must reject D64 one-hot catalog"); + .expect_err("adaptive dense preset must reject adaptive one-hot catalog"); assert!( matches!(err, akita_field::AkitaError::InvalidSetup(_)), diff --git a/crates/akita-pcs/Cargo.toml b/crates/akita-pcs/Cargo.toml index d3c9de399..14b0bfd26 100644 --- a/crates/akita-pcs/Cargo.toml +++ b/crates/akita-pcs/Cargo.toml @@ -46,23 +46,23 @@ parallel = [ ] schedules-default = ["akita-config/schedules-default"] profile-ci = [ - "akita-config/schedules-fp128-mixed-dim-onehot", + "akita-config/schedules-fp128-onehot", "akita-config/schedules-fp32-d128-onehot", "akita-config/schedules-fp64-d128-onehot", - "akita-config/schedules-fp128-d64-onehot", - "akita-config/schedules-fp128-d64-onehot-recursive", - "akita-config/schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2", - "akita-config/schedules-fp128-d64-dense", - "akita-config/schedules-fp128-d64-onehot-multi-chunk", - "akita-config/schedules-fp128-d64-onehot-multi-chunk-w2r2", - "akita-config/schedules-fp128-d64-onehot-multi-chunk-w4r2", + "akita-config/schedules-fp128-onehot-recursive", + "akita-config/schedules-fp128-onehot-recursive-multi-chunk-w8r2", + "akita-config/schedules-fp128-dense", + "akita-config/schedules-fp128-onehot-multi-chunk", + "akita-config/schedules-fp128-onehot-multi-chunk", + "akita-config/schedules-fp128-onehot-multi-chunk-w2r2", + "akita-config/schedules-fp128-onehot-multi-chunk-w4r2", ] -# Compile the profile example with only the singleton fp128 D64 one-hot +# Compile the profile example with only the singleton adaptive fp128 one-hot # configuration. Run with `--no-default-features` so unrelated schedule tables # and profile-mode monomorphizations stay out of the binary. -profile-onehot-fp128-d64 = ["akita-config/schedules-fp128-d64-onehot"] -schedules-fp128-d64-dense-multi-chunk = [ - "akita-config/schedules-fp128-d64-dense-multi-chunk", +profile-onehot-fp128 = ["akita-config/schedules-fp128-onehot"] +schedules-fp128-dense-multi-chunk = [ + "akita-config/schedules-fp128-dense-multi-chunk", ] disk-persistence = ["akita-setup/disk-persistence"] logging-transcript = [ diff --git a/crates/akita-pcs/benches/akita_e2e.rs b/crates/akita-pcs/benches/akita_e2e.rs index 63f1ad5c5..1bc496ca9 100644 --- a/crates/akita-pcs/benches/akita_e2e.rs +++ b/crates/akita-pcs/benches/akita_e2e.rs @@ -247,7 +247,7 @@ fn bench_dense_phases>( +fn bench_onehot_phases>( c: &mut Criterion, label: &str, nv: usize, @@ -257,8 +257,10 @@ fn bench_onehot_phases::new(onehot_k, D, indices.clone()).unwrap(); + let onehot_poly = OneHotPoly::::new(onehot_k, root_ring_dimension, indices.clone()).unwrap(); let dense_evals: Vec = { let mut evals = vec![F::from_u64(0); total_field]; @@ -418,31 +420,31 @@ fn bench_onehot_phases(c, "dense-d128", 15); +fn bench_dense_nv14(c: &mut Criterion) { + bench_dense_phases::<{ fp128::Dense::D }, fp128::Dense>(c, "dense-adaptive", 14); } -fn bench_dense_nv20(c: &mut Criterion) { - bench_dense_phases::<{ fp128::D128Dense::D }, fp128::D128Dense>(c, "dense-d128", 20); +fn bench_dense_nv16(c: &mut Criterion) { + bench_dense_phases::<{ fp128::Dense::D }, fp128::Dense>(c, "dense-adaptive", 16); } -fn bench_dense_nv25(c: &mut Criterion) { - bench_dense_phases::<{ fp128::D128Dense::D }, fp128::D128Dense>(c, "dense-d128", 25); +fn bench_dense_nv24(c: &mut Criterion) { + bench_dense_phases::<{ fp128::Dense::D }, fp128::Dense>(c, "dense-adaptive", 24); } fn bench_onehot_nv15(c: &mut Criterion) { - bench_onehot_phases::<{ fp128::D64OneHot::D }, fp128::D64OneHot>(c, "onehot-d64", 15); + bench_onehot_phases::(c, "onehot-adaptive", 15); } fn bench_onehot_nv20(c: &mut Criterion) { - bench_onehot_phases::<{ fp128::D64OneHot::D }, fp128::D64OneHot>(c, "onehot-d64", 20); + bench_onehot_phases::(c, "onehot-adaptive", 20); } fn bench_onehot_nv25(c: &mut Criterion) { - bench_onehot_phases::<{ fp128::D64OneHot::D }, fp128::D64OneHot>(c, "onehot-d64", 25); + bench_onehot_phases::(c, "onehot-adaptive", 25); } criterion_group!( akita_benches, - bench_dense_nv15, - bench_dense_nv20, - bench_dense_nv25, + bench_dense_nv14, + bench_dense_nv16, + bench_dense_nv24, bench_onehot_nv15, bench_onehot_nv20, bench_onehot_nv25, diff --git a/crates/akita-pcs/benches/root_kernels.rs b/crates/akita-pcs/benches/root_kernels.rs index edfedbe24..a249140f9 100644 --- a/crates/akita-pcs/benches/root_kernels.rs +++ b/crates/akita-pcs/benches/root_kernels.rs @@ -15,9 +15,9 @@ use rand::rngs::StdRng; use rand::{Rng, SeedableRng}; type F = fp128::Field; -type Cfg = fp128::D64Dense; +type Cfg = fp128::Dense; const D: usize = Cfg::D; -const NV: usize = 25; +const NV: usize = 24; fn make_dense_evals>(nv: usize) -> Vec { let mut rng = StdRng::seed_from_u64(0xdead_beef); @@ -35,7 +35,7 @@ fn make_dense_evals>(nv: usize) -> Vec { } } -fn bench_dense_root_matvec_full_nv25_d32(c: &mut Criterion) { +fn bench_dense_root_matvec_full_nv24_d256(c: &mut Criterion) { let evals = make_dense_evals::(NV); let poly = DensePoly::::from_field_evals(NV, D, &evals).expect("dense poly"); let layout = Cfg::get_params_for_batched_commitment( @@ -70,7 +70,7 @@ fn bench_dense_root_matvec_full_nv25_d32(c: &mut Criterion) { let inner_width = layout.inner_width(); let mut group = c.benchmark_group("root_kernels"); - group.bench_function("dense_root_matvec_full_nv25_d32", |b| { + group.bench_function("dense_root_matvec_full_nv24_d256", |b| { b.iter(|| { black_box(mat_vec_mul_ntt_i8_dense( &ntt_shared, @@ -84,7 +84,7 @@ fn bench_dense_root_matvec_full_nv25_d32(c: &mut Criterion) { }) }); group.bench_function( - "dense_root_matvec_full_nv25_d32_single_row_subkernel", + "dense_root_matvec_full_nv24_d256_single_row_subkernel", |b| { b.iter(|| { black_box(mat_vec_mul_ntt_i8_dense_single_row( @@ -102,7 +102,7 @@ fn bench_dense_root_matvec_full_nv25_d32(c: &mut Criterion) { .iter() .map(|block| vec![[0i8; D]; block.len() * layout.num_digits_inner]) .collect(); - group.bench_function("dense_root_predecomp_digit_matvec_full_nv25_d32", |b| { + group.bench_function("dense_root_predecomp_digit_matvec_full_nv24_d256", |b| { b.iter(|| { for (block, digit_block) in block_slices.iter().zip(digit_blocks.iter_mut()) { decompose_rows_i8_into( @@ -127,5 +127,5 @@ fn bench_dense_root_matvec_full_nv25_d32(c: &mut Criterion) { group.finish(); } -criterion_group!(root_kernels, bench_dense_root_matvec_full_nv25_d32); +criterion_group!(root_kernels, bench_dense_root_matvec_full_nv24_d256); criterion_main!(root_kernels); diff --git a/crates/akita-pcs/examples/profile/main.rs b/crates/akita-pcs/examples/profile/main.rs index d5ff112b3..19fd464ac 100644 --- a/crates/akita-pcs/examples/profile/main.rs +++ b/crates/akita-pcs/examples/profile/main.rs @@ -4,7 +4,7 @@ mod modes; mod ntt_prewarm; mod parallel; mod report; -#[cfg_attr(feature = "profile-onehot-fp128-d64", allow(dead_code))] +#[cfg_attr(feature = "profile-onehot-fp128", allow(dead_code))] mod workload; use std::env; @@ -43,13 +43,10 @@ fn main() { let nv: usize = env::var("AKITA_NUM_VARS") .ok() .and_then(|s| s.parse().ok()) - .unwrap_or(25); + .unwrap_or(32); let num_polys = env_usize("AKITA_NUM_POLYS", 1); - // Keep the default explicit: adaptive `dense`/`onehot` selectors are - // intentionally not part of the profile surface. D64 is the default fp128 - // profile preset (`onehot_fp128_d64`); use best_*_schedule to compare D64 vs D128. - let mode = env::var("AKITA_MODE").unwrap_or_else(|_| "onehot_fp128_d64".to_string()); + let mode = env::var("AKITA_MODE").unwrap_or_else(|_| "onehot_fp128".to_string()); let enable_trace = env_flag("AKITA_PROFILE_TRACE", true); let enable_ansi = env_flag("AKITA_PROFILE_ANSI", true); let span_events = if env_flag("AKITA_PROFILE_SPAN_CLOSES", true) { @@ -102,7 +99,7 @@ fn main() { tracing::info!(num_vars = nv, num_polys, mode = %mode, "profile config"); modes::log_active_fp128_prime_probe(); - #[cfg(not(feature = "profile-onehot-fp128-d64"))] + #[cfg(not(feature = "profile-onehot-fp128"))] { if mode == "all" { modes::run_all_profile_modes(nv); @@ -110,7 +107,7 @@ fn main() { modes::run_profile_mode(&mode, nv, num_polys); } } - #[cfg(feature = "profile-onehot-fp128-d64")] + #[cfg(feature = "profile-onehot-fp128")] modes::run_profile_mode(&mode, nv, num_polys); if enable_trace { diff --git a/crates/akita-pcs/examples/profile/modes.rs b/crates/akita-pcs/examples/profile/modes.rs index e094e51fc..122c23d09 100644 --- a/crates/akita-pcs/examples/profile/modes.rs +++ b/crates/akita-pcs/examples/profile/modes.rs @@ -1,9 +1,9 @@ -#![cfg_attr(feature = "profile-onehot-fp128-d64", allow(dead_code))] +#![cfg_attr(feature = "profile-onehot-fp128", allow(dead_code))] use crate::report::print_layout; use crate::workload::{ - onehot_k_for_num_vars, run_batched_onehot, run_dense_for, run_onehot, - run_recursive_multi_group_onehot, + onehot_k_for_num_vars, profile_setup_contribution_mode, run_batched_onehot, run_dense_for, + run_onehot, run_recursive_multi_group_onehot, }; use akita_config::proof_optimized::{fp128, fp32, fp64}; use akita_config::CommitmentConfig; @@ -17,7 +17,7 @@ use akita_field::{ use akita_serialization::{AkitaSerialize, Valid}; use akita_types::{ AkitaScheduleLookupKey, CommittedGroupParams, FpExtEncoding, MultiChunkProfileId, - PolynomialGroupLayout, + PolynomialGroupLayout, SetupContributionMode, }; type F = fp128::Field; @@ -164,48 +164,48 @@ fn run_onehot_mode(label, title, nv, num_polys); } -#[cfg(not(feature = "profile-onehot-fp128-d64"))] +#[cfg(not(feature = "profile-onehot-fp128"))] type ProfileModeRunner = fn(usize, usize); -#[cfg(not(feature = "profile-onehot-fp128-d64"))] +#[cfg(not(feature = "profile-onehot-fp128"))] struct ProfileMode { name: &'static str, run: ProfileModeRunner, } -#[cfg(all(not(feature = "profile-onehot-fp128-d64"), feature = "profile-ci"))] +#[cfg(all(not(feature = "profile-onehot-fp128"), feature = "profile-ci"))] const PROFILE_CI_MODES: &[ProfileMode] = &[ ProfileMode { - name: "dense_fp128_d64", - run: run_profile_dense_fp128_d64, + name: "dense_fp128", + run: run_profile_dense_fp128, }, ProfileMode { - name: "onehot_fp128_d64", - run: run_profile_onehot_fp128_d64, + name: "onehot_fp128", + run: run_profile_onehot_fp128, }, ProfileMode { - name: "onehot_fp128_mixed_dim", - run: run_profile_onehot_fp128_mixed_dim, + name: "onehot_fp128_multi_group", + run: run_profile_onehot_fp128_multi_group, }, ProfileMode { - name: "onehot_fp128_d64_multi_group_recursive", - run: run_profile_onehot_fp128_d64_multi_group_recursive, + name: "onehot_fp128_multi_group_recursive", + run: run_profile_onehot_fp128_multi_group_recursive, }, ProfileMode { - name: "onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2", - run: run_profile_onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2, + name: "onehot_fp128_multi_group_recursive_multi_chunk_w8r2", + run: run_profile_onehot_fp128_multi_group_recursive_multi_chunk_w8r2, }, ProfileMode { - name: "onehot_fp128_d64_multi_chunk_w2r2", - run: run_profile_onehot_fp128_d64_multi_chunk_w2r2, + name: "onehot_fp128_multi_chunk_w2r2", + run: run_profile_onehot_fp128_multi_chunk_w2r2, }, ProfileMode { - name: "onehot_fp128_d64_multi_chunk_w4r2", - run: run_profile_onehot_fp128_d64_multi_chunk_w4r2, + name: "onehot_fp128_multi_chunk_w4r2", + run: run_profile_onehot_fp128_multi_chunk_w4r2, }, ProfileMode { - name: "onehot_fp128_d64_multi_chunk_w8r2", - run: run_profile_onehot_fp128_d64_multi_chunk_w8r2, + name: "onehot_fp128_multi_chunk_w8r2", + run: run_profile_onehot_fp128_multi_chunk_w8r2, }, ProfileMode { name: "onehot_fp32_d128", @@ -217,43 +217,39 @@ const PROFILE_CI_MODES: &[ProfileMode] = &[ }, ]; -#[cfg(all(not(feature = "profile-onehot-fp128-d64"), not(feature = "profile-ci")))] +#[cfg(all(not(feature = "profile-onehot-fp128"), not(feature = "profile-ci")))] const PROFILE_ALL_MODES: &[ProfileMode] = &[ ProfileMode { - name: "dense_fp128_d64", - run: run_profile_dense_fp128_d64, + name: "dense_fp128", + run: run_profile_dense_fp128, }, ProfileMode { - name: "onehot_fp128_d64", - run: run_profile_onehot_fp128_d64, + name: "onehot_fp128", + run: run_profile_onehot_fp128, }, ProfileMode { - name: "onehot_fp128_d64_multi_group_recursive", - run: run_profile_onehot_fp128_d64_multi_group_recursive, + name: "onehot_fp128_multi_group", + run: run_profile_onehot_fp128_multi_group, }, ProfileMode { - name: "onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2", - run: run_profile_onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2, + name: "onehot_fp128_multi_group_recursive", + run: run_profile_onehot_fp128_multi_group_recursive, }, ProfileMode { - name: "dense_fp128_d128", - run: run_profile_dense_fp128_d128, + name: "onehot_fp128_multi_group_recursive_multi_chunk_w8r2", + run: run_profile_onehot_fp128_multi_group_recursive_multi_chunk_w8r2, }, ProfileMode { - name: "onehot_fp128_d128", - run: run_profile_onehot_fp128_d128, + name: "onehot_fp128_multi_chunk_w2r2", + run: run_profile_onehot_fp128_multi_chunk_w2r2, }, ProfileMode { - name: "onehot_fp128_d64_multi_chunk_w2r2", - run: run_profile_onehot_fp128_d64_multi_chunk_w2r2, + name: "onehot_fp128_multi_chunk_w4r2", + run: run_profile_onehot_fp128_multi_chunk_w4r2, }, ProfileMode { - name: "onehot_fp128_d64_multi_chunk_w4r2", - run: run_profile_onehot_fp128_d64_multi_chunk_w4r2, - }, - ProfileMode { - name: "onehot_fp128_d64_multi_chunk_w8r2", - run: run_profile_onehot_fp128_d64_multi_chunk_w8r2, + name: "onehot_fp128_multi_chunk_w8r2", + run: run_profile_onehot_fp128_multi_chunk_w8r2, }, ProfileMode { name: "dense_fp32_d64", @@ -285,7 +281,7 @@ const PROFILE_ALL_MODES: &[ProfileMode] = &[ }, ]; -#[cfg(not(feature = "profile-onehot-fp128-d64"))] +#[cfg(not(feature = "profile-onehot-fp128"))] fn profile_modes() -> &'static [ProfileMode] { #[cfg(feature = "profile-ci")] { @@ -298,18 +294,17 @@ fn profile_modes() -> &'static [ProfileMode] { } /// Modes registered for explicit `AKITA_MODE=…` runs but omitted from `all`. -#[cfg(not(feature = "profile-onehot-fp128-d64"))] +#[cfg(not(feature = "profile-onehot-fp128"))] const EXCLUDED_FROM_ALL_SWEEP: &[&str] = &[ - "onehot_fp128_d64_multi_chunk_w2r2", - "onehot_fp128_d64_multi_chunk_w4r2", - "onehot_fp128_d64_multi_chunk_w8r2", - "onehot_fp128_d64_multi_group_recursive", - "onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2", + "onehot_fp128_multi_group", + "onehot_fp128_multi_chunk_w2r2", + "onehot_fp128_multi_chunk_w4r2", + "onehot_fp128_multi_chunk_w8r2", + "onehot_fp128_multi_group_recursive", + "onehot_fp128_multi_group_recursive_multi_chunk_w8r2", // D128+ presets are heavy and/or runtime-DP-backed; keep them out of the // default `all` smoke sweep (they are still selectable by explicit // `AKITA_MODE=` and drive the profile-bench matrix). - "dense_fp128_d128", - "onehot_fp128_d128", "dense_fp32_d128", "onehot_fp32_d128", "onehot_fp64_d128", @@ -322,18 +317,6 @@ fn assert_singleton_mode(mode: &str, num_polys: usize) { ); } -fn fp128_onehot_title(d: usize, nv: usize, num_polys: usize) -> String { - let onehot_k = onehot_k_for_num_vars(nv); - let prime = fp128_prime_label(); - if num_polys == 1 { - format!("=== onehot_fp128_d{d} (fp128, {prime}, D={d}, 1-of-{onehot_k}, log_commit_bound=1) ===") - } else { - format!( - "=== onehot_fp128_d{d} batched (fp128, {prime}, D={d}, 1-of-{onehot_k}, log_commit_bound=1, same-point batch={num_polys}) ===" - ) - } -} - fn small_field_schedule_source(d: usize) -> &'static str { if d >= 128 { "runtime DP schedule (no shipped D128 table)" @@ -362,33 +345,29 @@ fn small_field_dense_title(field_label: &str, d: usize) -> String { format!("=== dense_{field_label}_d{d} ({field_label}, D={d}, {schedule}) ===") } -fn run_profile_dense_fp128_d64(nv: usize, num_polys: usize) { - type Cfg = fp128::D64Dense; - assert_singleton_mode("dense_fp128_d64", num_polys); +fn run_profile_dense_fp128(nv: usize, num_polys: usize) { + type Cfg = fp128::Dense; + assert_singleton_mode("dense_fp128", num_polys); let prime = fp128_prime_label(); run_dense_mode::<{ Cfg::D }, Cfg>( - "dense_fp128_d64", - &format!("=== dense_fp128_d64 (fp128, {prime}, D=64 dense, log_commit_bound=128) ==="), + "dense_fp128", + &format!("=== dense_fp128 (fp128, {prime}, generated per-level dimensions) ==="), nv, ); } -fn run_profile_onehot_fp128_d64(nv: usize, num_polys: usize) { - type Cfg = fp128::D64OneHot; - let title = fp128_onehot_title(64, nv, num_polys); - run_onehot_mode::<{ Cfg::D }, Cfg>("onehot_fp128_d64", &title, nv, num_polys); -} - -#[cfg(feature = "profile-ci")] -fn run_profile_onehot_fp128_mixed_dim(nv: usize, num_polys: usize) { - type Cfg = fp128::MixedDimFp128OneHot; - assert_eq!(nv, 32, "mixed-dimension profile fixes nv=32"); - assert_singleton_mode("onehot_fp128_mixed_dim", num_polys); +fn run_profile_onehot_fp128(nv: usize, num_polys: usize) { + type Cfg = fp128::OneHot; + assert!( + matches!(nv, 32 | 36), + "fp128 one-hot profile supports generated nv=32 and nv=36 rows" + ); + assert_singleton_mode("onehot_fp128", num_polys); let schedule = Cfg::runtime_schedule(AkitaScheduleLookupKey::single( PolynomialGroupLayout::singleton(nv), )) - .expect("generated mixed-dimension schedule"); + .expect("generated fp128 one-hot schedule"); let selected_dims = std::iter::once(schedule.root.params.final_group.commitment.role_dims()) .chain( schedule @@ -399,34 +378,25 @@ fn run_profile_onehot_fp128_mixed_dim(nv: usize, num_polys: usize) { .collect::>(); tracing::info!( selected_dims = ?selected_dims, - "generated mixed-dimension schedule selection" + "generated fp128 one-hot schedule selection" ); let layout = resolve_layout::(nv); tracing::info!( - "=== onehot_fp128_mixed_dim (fp128, flat public setup, generated per-level dimensions, 1-of-256) ===" + "=== onehot_fp128 (fp128, flat public setup, generated per-level dimensions, 1-of-256) ===" ); print_layout(&layout, 1, Cfg::decomposition().field_bits()); // The catalog row selected here is the same exact row used by the PCS // prover and verifier. The benchmark intentionally does not compare it // against a different uniform-D family. - run_onehot::( - "onehot_fp128_mixed_dim", - nv, - &layout, - Some(&schedule), - false, - ); + run_onehot::("onehot_fp128", nv, &layout, Some(&schedule), false); } -/// Shared driver for the recursive multi-group profiles. Every such profile +/// Shared driver for the multi-group profiles. Every such profile /// fixes the same shape (two precommitted 16-var singleton groups + a 32-var /// main group with 2 polynomials, i.e. `num_polys == 4`); only the base preset /// (`Cfg`) and the `layout_note` describing its witness layout differ. -fn run_recursive_multi_group_mode< - const D: usize, - Cfg: CommitmentConfig, ->( +fn run_multi_group_mode>( label: &str, layout_note: &str, nv: usize, @@ -444,33 +414,42 @@ fn run_recursive_multi_group_mode< run_recursive_multi_group_onehot::(label, 16, 32, 2); } -fn run_profile_onehot_fp128_d64_multi_group_recursive(nv: usize, num_polys: usize) { - type Cfg = fp128::D64OneHot; - run_recursive_multi_group_mode::<{ Cfg::D }, Cfg>( - "onehot_fp128_d64_multi_group_recursive", - "recursive setup", +fn run_profile_onehot_fp128_multi_group(nv: usize, num_polys: usize) { + type Cfg = fp128::OneHot; + assert_eq!( + profile_setup_contribution_mode(), + SetupContributionMode::Direct, + "onehot_fp128_multi_group supports direct setup contribution only" + ); + run_multi_group_mode::<{ Cfg::D }, Cfg>( + "onehot_fp128_multi_group", + "generated per-level dimensions", nv, num_polys, ); } -fn run_profile_onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2( - nv: usize, - num_polys: usize, -) { - // `D64OneHotMultiChunk` is the production W8R2 preset (8 chunks x 2 leading - // levels); the recursive adapter (applied inside - // `run_recursive_multi_group_onehot`) adds setup offloading. - type Cfg = fp128::D64OneHotMultiChunk; - run_recursive_multi_group_mode::<{ Cfg::D }, Cfg>( - "onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2", - "recursive setup offloading + W8R2 chunked witness: num_chunks=8 x 2 leading levels", +fn run_profile_onehot_fp128_multi_group_recursive(nv: usize, num_polys: usize) { + type Cfg = fp128::OneHot; + run_multi_group_mode::<{ Cfg::D }, Cfg>( + "onehot_fp128_multi_group_recursive", + "adaptive ring dimensions + recursive setup", + nv, + num_polys, + ); +} + +fn run_profile_onehot_fp128_multi_group_recursive_multi_chunk_w8r2(nv: usize, num_polys: usize) { + type Cfg = fp128::OneHotMultiChunk; + run_multi_group_mode::<{ Cfg::D }, Cfg>( + "onehot_fp128_multi_group_recursive_multi_chunk_w8r2", + "adaptive ring dimensions + recursive setup offloading + W8R2 chunked witness: num_chunks=8 x 2 leading levels", nv, num_polys, ); } -fn run_profile_onehot_fp128_d64_multi_chunk_named< +fn run_profile_onehot_fp128_multi_chunk_named< const D: usize, Cfg: CommitmentConfig, >( @@ -482,61 +461,40 @@ fn run_profile_onehot_fp128_d64_multi_chunk_named< let prime = fp128_prime_label(); let onehot_k = onehot_k_for_num_vars(nv); let title = format!( - "=== {label} (fp128, {prime}, D=64, 1-of-{onehot_k}, distributed chunked relation, num_chunks={} x {} leading levels) ===", + "=== {label} (fp128, {prime}, adaptive ring dimensions, 1-of-{onehot_k}, distributed chunked relation, num_chunks={} x {} leading levels) ===", profile.num_chunks(), profile.num_activated_levels(), ); run_onehot_mode::(label, &title, nv, num_polys); } -fn run_profile_onehot_fp128_d64_multi_chunk_w8r2(nv: usize, num_polys: usize) { - run_profile_onehot_fp128_d64_multi_chunk_named::<64, fp128::D64OneHotMultiChunk>( - "onehot_fp128_d64_multi_chunk_w8r2", +fn run_profile_onehot_fp128_multi_chunk_w8r2(nv: usize, num_polys: usize) { + run_profile_onehot_fp128_multi_chunk_named::<256, fp128::OneHotMultiChunk>( + "onehot_fp128_multi_chunk_w8r2", MultiChunkProfileId::W8R2, nv, num_polys, ); } -fn run_profile_onehot_fp128_d64_multi_chunk_w2r2(nv: usize, num_polys: usize) { - run_profile_onehot_fp128_d64_multi_chunk_named::<64, fp128::D64OneHotMultiChunkW2R2>( - "onehot_fp128_d64_multi_chunk_w2r2", +fn run_profile_onehot_fp128_multi_chunk_w2r2(nv: usize, num_polys: usize) { + run_profile_onehot_fp128_multi_chunk_named::<256, fp128::OneHotMultiChunkW2R2>( + "onehot_fp128_multi_chunk_w2r2", MultiChunkProfileId::W2R2, nv, num_polys, ); } -fn run_profile_onehot_fp128_d64_multi_chunk_w4r2(nv: usize, num_polys: usize) { - run_profile_onehot_fp128_d64_multi_chunk_named::<64, fp128::D64OneHotMultiChunkW4R2>( - "onehot_fp128_d64_multi_chunk_w4r2", +fn run_profile_onehot_fp128_multi_chunk_w4r2(nv: usize, num_polys: usize) { + run_profile_onehot_fp128_multi_chunk_named::<256, fp128::OneHotMultiChunkW4R2>( + "onehot_fp128_multi_chunk_w4r2", MultiChunkProfileId::W4R2, nv, num_polys, ); } -#[cfg(not(feature = "profile-ci"))] -fn run_profile_dense_fp128_d128(nv: usize, num_polys: usize) { - type Cfg = fp128::D128Dense; - assert_singleton_mode("dense_fp128_d128", num_polys); - let prime = fp128_prime_label(); - run_dense_mode::<{ Cfg::D }, Cfg>( - "dense_fp128_d128", - &format!( - "=== dense_fp128_d128 (fp128, {prime}, D=128 dense, log_commit_bound=128, runtime DP schedule) ===" - ), - nv, - ); -} - -#[cfg(not(feature = "profile-ci"))] -fn run_profile_onehot_fp128_d128(nv: usize, num_polys: usize) { - type Cfg = fp128::D128OneHot; - let title = fp128_onehot_title(128, nv, num_polys); - run_onehot_mode::<{ Cfg::D }, Cfg>("onehot_fp128_d128", &title, nv, num_polys); -} - #[cfg(not(feature = "profile-ci"))] fn run_profile_onehot_fp32_d64(nv: usize, num_polys: usize) { type Cfg = fp32::D64OneHot; @@ -587,7 +545,7 @@ fn run_profile_dense_fp64_d64(nv: usize, num_polys: usize) { run_dense_mode_for::("dense_fp64_d64", &title, nv); } -#[cfg(not(feature = "profile-onehot-fp128-d64"))] +#[cfg(not(feature = "profile-onehot-fp128"))] pub(crate) fn run_profile_mode(mode: &str, nv: usize, num_polys: usize) { let modes = profile_modes(); let profile_mode = modes @@ -606,7 +564,7 @@ pub(crate) fn run_profile_mode(mode: &str, nv: usize, num_polys: usize) { (profile_mode.run)(nv, num_polys); } -#[cfg(not(feature = "profile-onehot-fp128-d64"))] +#[cfg(not(feature = "profile-onehot-fp128"))] pub(crate) fn run_all_profile_modes(nv: usize) { for entry in profile_modes() { if EXCLUDED_FROM_ALL_SWEEP.contains(&entry.name) { @@ -622,17 +580,17 @@ fn resolve_layout>(nv: usize) -> Committed ) .expect("layout") } -#[cfg(feature = "profile-onehot-fp128-d64")] +#[cfg(feature = "profile-onehot-fp128")] pub(crate) fn run_profile_mode(mode: &str, nv: usize, num_polys: usize) { assert_eq!( - mode, "onehot_fp128_d64", - "profile-onehot-fp128-d64 only supports AKITA_MODE=onehot_fp128_d64", + mode, "onehot_fp128", + "profile-onehot-fp128 only supports AKITA_MODE=onehot_fp128", ); assert_eq!( num_polys, 1, - "profile-onehot-fp128-d64 only supports singleton commitments" + "profile-onehot-fp128 only supports singleton commitments" ); - run_profile_onehot_fp128_d64(nv, num_polys); + run_profile_onehot_fp128(nv, num_polys); } pub(crate) fn log_active_fp128_prime_probe() { diff --git a/crates/akita-pcs/examples/profile/workload.rs b/crates/akita-pcs/examples/profile/workload.rs index 0760f98cc..3a1c0876e 100644 --- a/crates/akita-pcs/examples/profile/workload.rs +++ b/crates/akita-pcs/examples/profile/workload.rs @@ -299,9 +299,9 @@ fn assert_runtime_matches_planned_proof_size( } } -/// Required setup-contribution mode for the config-typed recursive multi-group -/// profile. Scalar profiles are direct by construction. -fn profile_setup_contribution_mode() -> SetupContributionMode { +/// Required setup-contribution mode for config-typed multi-group profiles. +/// Scalar profiles are direct by construction. +pub(crate) fn profile_setup_contribution_mode() -> SetupContributionMode { match std::env::var("AKITA_SETUP_MODE").ok().as_deref() { Some("recursive") => SetupContributionMode::Recursive, Some("direct") | None => SetupContributionMode::Direct, @@ -436,14 +436,44 @@ where let low_vars = onehot_k.trailing_zeros() as usize; let low_weights = lagrange_weights(&point[..low_vars]).expect("valid low opening point"); - let high_weights = lagrange_weights(&point[low_vars..]).expect("valid high opening point"); - poly.indices() + let high_point = &point[low_vars..]; + let mut high_weight = high_point .iter() - .enumerate() - .filter_map(|(chunk_idx, hot_idx)| { - hot_idx.map(|hot_idx| high_weights[chunk_idx] * low_weights[hot_idx.as_usize()]) + .copied() + .map(|r| E::one() - r) + .fold(E::one(), |acc, value| acc * value); + let transitions = high_point + .iter() + .copied() + .map(|r| { + let one_minus_r = E::one() - r; + let to_one = r * one_minus_r + .inverse() + .expect("non-Boolean random opening point"); + let to_zero = one_minus_r * r.inverse().expect("non-Boolean random opening point"); + (to_one, to_zero) }) - .fold(E::zero(), |acc, weight| acc + weight) + .collect::>(); + let mut opening = E::zero(); + let mut gray_index = 0usize; + for step in 0..poly.indices().len() { + if let Some(hot_idx) = poly.indices()[gray_index] { + opening += high_weight * low_weights[hot_idx.as_usize()]; + } + let next_step = step + 1; + if next_step == poly.indices().len() { + break; + } + let next_gray = next_step ^ (next_step >> 1); + let flipped_bit = (gray_index ^ next_gray).trailing_zeros() as usize; + high_weight *= if next_gray & (1usize << flipped_bit) == 0 { + transitions[flipped_bit].1 + } else { + transitions[flipped_bit].0 + }; + gray_index = next_gray; + } + opening } fn opening_from_poly<'a, FF, const D: usize, P>( @@ -751,7 +781,7 @@ pub(crate) fn run_dense_for() + .shared_ntt_profile(layout.d_a()) .expect("prepared setup CRT profile"), ); run_prove::>( @@ -829,7 +859,7 @@ pub(crate) fn run_onehot>( report_crt_profile( label, prepared - .shared_ntt_profile::() + .shared_ntt_profile(layout.d_a()) .expect("prepared setup CRT profile"), ); run_prove::>( @@ -922,7 +952,7 @@ pub(crate) fn run_batched_onehot() + .shared_ntt_profile(layout.d_a()) .expect("prepared setup CRT profile"), ); let t0 = Instant::now(); @@ -1225,7 +1255,7 @@ fn run_recursive_multi_group_onehot_with_proof_cfg() + .shared_ntt_profile(schedule.root.params.final_group.commitment.d_a()) .expect("prepared setup CRT profile"), ); let mut pre_keys = Vec::with_capacity(PRE_GROUPS); diff --git a/crates/akita-pcs/examples/transcript_schedule.rs b/crates/akita-pcs/examples/transcript_schedule.rs index 63204a8c3..1a463c347 100644 --- a/crates/akita-pcs/examples/transcript_schedule.rs +++ b/crates/akita-pcs/examples/transcript_schedule.rs @@ -30,7 +30,7 @@ fn main() { transcript.assert_smell_checks(); println!( "Akita transcript schedule example using D={}", - fp128::D64OneHot::D + fp128::OneHot::D ); for (index, event) in transcript.events().iter().enumerate() { println!("{index:02}: {}", format_event(event)); diff --git a/crates/akita-pcs/src/scheme/tests/dense_group.rs b/crates/akita-pcs/src/scheme/tests/dense_group.rs index 47dc67222..64fe90536 100644 --- a/crates/akita-pcs/src/scheme/tests/dense_group.rs +++ b/crates/akita-pcs/src/scheme/tests/dense_group.rs @@ -4,7 +4,7 @@ type DenseGroupCfg = Cfg; type DenseGroupScheme = AkitaCommitmentScheme; #[test] -fn dense_group_round_trips() { +fn dense_group_commit_freezes_uniform_precommit_profile() { const NUM_VARS: usize = 16; let setup = DenseGroupScheme::setup_prover(NUM_VARS, 1).expect("dense group setup"); @@ -20,90 +20,18 @@ fn dense_group_round_trips() { .collect::>(); let poly = DensePoly::::from_field_evals(NUM_VARS, D, &evals).expect("dense polynomial"); - let (commitment, hint) = + let (commitment, _hint) = DenseGroupScheme::commit_group(&setup, std::slice::from_ref(&poly), &stack) .expect("dense group commit"); - let point = (0..NUM_VARS) - .map(|index| F::from_u64((index + 2) as u64)) - .collect::>(); - let opening = dense_opening(&evals, &point); - let prover_claims = OpeningClaims::from_groups(vec![PolynomialGroupClaims::new( - point.clone(), - vec![opening], - commitment.clone(), - ) - .expect("dense prover claim")]) - .expect("dense prover claims"); - let poly_refs = [&poly]; - let prover_data = - selected_prover_data::(prover_claims, vec![hint], vec![&poly_refs]) - .expect("dense prover data"); - let selection = prover_data.0; - - const TRANSCRIPT_DOMAIN: &[u8] = b"test/dense-group"; - let mut prover_transcript = AkitaTranscript::::new(TRANSCRIPT_DOMAIN); - let proof = DenseGroupScheme::batched_prove( - &setup, - prover_data, - &stack, - &mut prover_transcript, - BasisMode::Lagrange, - ) - .expect("dense proof"); - - let verifier_setup = DenseGroupScheme::setup_verifier(&setup).expect("dense verifier setup"); - let verifier_claims = OpeningClaims::from_groups(vec![PolynomialGroupClaims::new( - point.clone(), - vec![opening], - &commitment, - ) - .expect("dense verifier claim")]) - .expect("dense verifier claims"); - let mut verifier_transcript = AkitaTranscript::::new(TRANSCRIPT_DOMAIN); - DenseGroupScheme::batched_verify( - &proof, - &verifier_setup, - &mut verifier_transcript, - GroupBatchStatement::new(selection, verifier_claims).expect("dense statement"), - BasisMode::Lagrange, - ) - .expect("dense verification"); - - let mut wrong_profile = commitment.clone(); - wrong_profile.profile.num_live_blocks = wrong_profile.profile.num_live_blocks.saturating_add(1); - let wrong_profile_claims = OpeningClaims::from_groups(vec![PolynomialGroupClaims::new( - point.clone(), - vec![opening], - &wrong_profile, - ) - .expect("wrong-profile dense verifier claim")]) - .expect("wrong-profile dense verifier claims"); - let mut wrong_profile_transcript = AkitaTranscript::::new(TRANSCRIPT_DOMAIN); - DenseGroupScheme::batched_verify( - &proof, - &verifier_setup, - &mut wrong_profile_transcript, - GroupBatchStatement::new(selection, wrong_profile_claims).expect("wrong-profile statement"), - BasisMode::Lagrange, - ) - .expect_err("changed committed profile must reject"); - let mut wrong_point = point; - wrong_point[0] += F::one(); - let wrong_point_claims = OpeningClaims::from_groups(vec![PolynomialGroupClaims::new( - wrong_point, - vec![opening], - &commitment, - ) - .expect("wrong-point dense verifier claim")]) - .expect("wrong-point dense verifier claims"); - let mut wrong_point_transcript = AkitaTranscript::::new(TRANSCRIPT_DOMAIN); - DenseGroupScheme::batched_verify( - &proof, - &verifier_setup, - &mut wrong_point_transcript, - GroupBatchStatement::new(selection, wrong_point_claims).expect("wrong-point statement"), - BasisMode::Lagrange, - ) - .expect_err("wrong opening point must reject"); + assert_eq!( + commitment.profile.group, + akita_types::PolynomialGroupLayout::new(NUM_VARS, 1) + ); + assert_eq!(commitment.profile.inner_commit_matrix.ring_dimension(), 64); + assert_eq!(commitment.profile.outer_commit_matrix.ring_dimension(), 64); + assert_eq!( + commitment.rows().count(), + commitment.profile.outer_commit_matrix.output_rank() + ); } diff --git a/crates/akita-pcs/src/scheme/tests/mod.rs b/crates/akita-pcs/src/scheme/tests/mod.rs index 0f425b205..2f03f7ca3 100644 --- a/crates/akita-pcs/src/scheme/tests/mod.rs +++ b/crates/akita-pcs/src/scheme/tests/mod.rs @@ -28,16 +28,16 @@ use akita_types::{ }; use rand::rngs::StdRng; use rand::{Rng, SeedableRng}; -type Cfg = fp128::D64Dense; +type Cfg = fp128::Dense; type F = fp128::Field; const D: usize = Cfg::D; type Scheme = AkitaCommitmentScheme; type OneHotF = fp128::Field; -type OneHotCfg = fp128::D64OneHot; +type OneHotCfg = fp128::OneHot; type PrecommittedOneHotCfg = PrecommittedCommitmentConfig; const ONEHOT_D: usize = OneHotCfg::D; -// `fp128::D64OneHot` uses K=256 one-hot chunks, spanning `K/D = 4` ring elements. +// `fp128::OneHot` uses K=256 one-hot chunks at its root ring dimension. const BENCH_ONEHOT_K: usize = 256; type OneHotScheme = AkitaCommitmentScheme; type PrecommittedOneHotScheme = AkitaCommitmentScheme; diff --git a/crates/akita-pcs/src/scheme/tests/onehot.rs b/crates/akita-pcs/src/scheme/tests/onehot.rs index 3e2b51506..b4c71ac02 100644 --- a/crates/akita-pcs/src/scheme/tests/onehot.rs +++ b/crates/akita-pcs/src/scheme/tests/onehot.rs @@ -387,8 +387,9 @@ fn multi_group_root_round_trip_onehot( .params .precommitted_groups .iter() - .all(|group| group.descriptor.inner_commit_matrix.ring_dimension() == TestCfg::D), - "precommitted groups must retain their native A dimension" + .zip(&pre_commitments) + .all(|(group, commitment)| group.descriptor == commitment.profile), + "precommitted groups must retain their exact native profiles" ); if TestCfg::chunked_witness_cfg().uses_multi_chunk() { let root = &multi_group_schedule.root; @@ -627,56 +628,16 @@ fn multi_group_root_opens_multi_polynomial_precommitted_group() { multi_group_root_round_trip_onehot::(14, 20, &[2], 1, false); } -#[test] -fn multi_group_root_allows_final_a_smaller_than_precommitted_a() { - const PRE_NV: usize = 14; - const FINAL_NV: usize = 24; - type ProtocolCfg = - crate::test_support::EnvelopeFinalGroupConfig; - - let pre_layout = OpeningClaimsLayout::new(PRE_NV, 1).expect("precommit layout"); - let pre_params = - as CommitmentConfig>:: - get_params_for_batched_commitment(&pre_layout) - .expect("precommit params"); - let test_pre_params = - as CommitmentConfig>:: - get_params_for_batched_commitment(&pre_layout) - .expect("test precommit params"); - assert_eq!( - pre_params.outer_commit_matrix.output_rank(), - test_pre_params.outer_commit_matrix.output_rank(), - "protocol and standalone precommit policies must freeze the same B rank" - ); - let key = akita_types::AkitaScheduleLookupKey { - final_group: akita_types::PolynomialGroupLayout::new(FINAL_NV, 2), - precommitteds: vec![akita_types::CommittedGroupProfile::from_params( - akita_types::PolynomialGroupLayout::new(PRE_NV, 1), - &pre_params, - )], - }; - let opening_layout = key.opening_layout().unwrap(); - let schedule = ProtocolCfg::runtime_schedule(key).expect("descending-A schedule"); - let root = multi_group_root_params(&schedule); - assert_eq!(root.d_a(), 64); - assert_eq!(root.group_role_dims(&opening_layout, 0).unwrap().d_a(), 128); - - multi_group_root_round_trip_onehot::( - PRE_NV, - FINAL_NV, - &[1], - 2, - true, - ); -} - #[test] #[cfg(feature = "profile-ci")] fn multi_group_multi_chunk_fold_round_trips() { - multi_group_root_round_trip_onehot::< - fp128::D64OneHotMultiChunkW2R2, - fp128::D64OneHotMultiChunkW2R2, - >(14, 14, &[1], 1, false); + multi_group_root_round_trip_onehot::( + 14, + 14, + &[1], + 1, + false, + ); } #[test] diff --git a/crates/akita-pcs/tests/akita_e2e.rs b/crates/akita-pcs/tests/akita_e2e.rs index adab58668..ce32b13a1 100644 --- a/crates/akita-pcs/tests/akita_e2e.rs +++ b/crates/akita-pcs/tests/akita_e2e.rs @@ -33,7 +33,7 @@ use std::sync::{Mutex, Once}; use std::time::Instant; mod common; -use common::opening_from_poly; +use common::opening_from_poly_for_layout; type F = fp128::Field; const ONEHOT_K: usize = 256; @@ -332,13 +332,13 @@ fn assert_invalid_proof( /// `num_chunks = 8` on the two leading fold levels (NV=16 ⇒ 64 blocks each). /// The single prover assembles the modified `[zᵢ|eᵢ|t̂ᵢ]…|r̂` relation and the /// verifier evaluates the chunked row-MLE; the proof must verify. -#[cfg(feature = "schedules-fp128-d64-dense-multi-chunk")] +#[cfg(feature = "schedules-fp128-dense-multi-chunk")] #[test] fn chunked_multi_chunk_prove_verify() { init_rayon_pool(); let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { - type Cfg = fp128::D64DenseMultiChunk; + type Cfg = fp128::DenseMultiChunk; const D: usize = Cfg::D; const NV: usize = 16; @@ -365,7 +365,7 @@ fn chunked_multi_chunk_prove_verify() { .collect(); let poly = DensePoly::::from_field_evals(NV, D, &evals).unwrap(); let pt = random_point::(NV); - let expected_opening = opening_from_poly::(&poly, &pt, &layout); + let expected_opening = opening_from_poly_for_layout(&poly, &pt, &layout); let setup = AkitaCommitmentScheme::::setup_prover(NV, 1).unwrap(); let prepared = CpuBackend.prepare_setup(&setup).unwrap(); @@ -427,28 +427,28 @@ fn chunked_multi_chunk_prove_verify() { verify_result.err() ); - tracing::info!(chunked_levels, proof_bytes, "chunked-d64/nv16 e2e"); + tracing::info!(chunked_levels, proof_bytes, "chunked-adaptive/nv16 e2e"); }); } #[test] -fn dense_d64_prove_verify() { +fn adaptive_dense_prove_verify() { init_rayon_pool(); let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { - type Cfg = fp128::D64Dense; - const D: usize = Cfg::D; + type Cfg = fp128::Dense; let layout = singleton_layout::(DENSE_TEST_NV); + let root_d = layout.d_a(); let mut rng = StdRng::seed_from_u64(0xdead_beef); let evals: Vec = (0..1usize << DENSE_TEST_NV) .map(|_| F::from_canonical_u128_reduced(rng.gen::())) .collect(); - let poly = DensePoly::::from_field_evals(DENSE_TEST_NV, D, &evals).unwrap(); + let poly = DensePoly::::from_field_evals(DENSE_TEST_NV, root_d, &evals).unwrap(); let pt = random_point::(DENSE_TEST_NV); - let expected_opening = opening_from_poly::(&poly, &pt, &layout); + let expected_opening = opening_from_poly_for_layout(&poly, &pt, &layout); #[cfg(feature = "disk-persistence")] purge_setup_cache(DENSE_TEST_NV); @@ -550,13 +550,13 @@ fn dense_d64_prove_verify() { }); } -/// Snap-regenerated `fp128_d64_dense` schedules must verify at production `nv` keys. +/// Generated adaptive dense schedules must verify at production `nv` keys. #[test] -fn dense_d64_snap_regen_prove_verify_nv24() { +fn adaptive_dense_generated_prove_verify_nv24() { init_rayon_pool(); let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { - type Cfg = fp128::D64Dense; + type Cfg = fp128::Dense; const D: usize = Cfg::D; const NV: usize = 24; @@ -591,7 +591,7 @@ fn trace_internalization_rejects_tampered_root_fold_handle() { init_rayon_pool(); let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { - type Cfg = fp128::D64Dense; + type Cfg = fp128::Dense; const D: usize = Cfg::D; let (verifier_setup, commitment, proof, opening_point, opening, _layout, selection) = @@ -623,14 +623,14 @@ fn trace_internalization_rejects_tampered_recursive_fold_handle() { init_rayon_pool(); let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { - type Cfg = fp128::D64OneHot; - const D: usize = Cfg::D; + type Cfg = fp128::OneHot; const NV: usize = 20; let opening_batch = akita_types::OpeningClaimsLayout::new(NV, 2).expect("opening_batch"); let layout = Cfg::get_params_for_batched_commitment(&opening_batch).expect("layout"); + let root_d = layout.d_a(); let total_field = (layout.num_live_blocks * layout.num_positions_per_block) - .checked_mul(D) + .checked_mul(root_d) .expect("total field size overflow"); let total_chunks = total_field / ONEHOT_K; assert_eq!(total_chunks * ONEHOT_K, total_field); @@ -641,14 +641,14 @@ fn trace_internalization_rejects_tampered_recursive_fold_handle() { let indices: Vec> = (0..total_chunks) .map(|_| Some(rng.gen_range(0..ONEHOT_K))) .collect(); - OneHotPoly::::new(ONEHOT_K, D, indices).unwrap() + OneHotPoly::::new(ONEHOT_K, root_d, indices).unwrap() }) .collect(); let poly_refs: Vec<&OneHotPoly> = polys.iter().collect(); let point = random_point(NV); let openings: Vec = polys .iter() - .map(|poly| opening_from_poly::(poly, &point, &layout)) + .map(|poly| opening_from_poly_for_layout(poly, &point, &layout)) .collect(); #[cfg(feature = "disk-persistence")] @@ -704,7 +704,7 @@ fn trace_internalization_rejects_tampered_terminal_e_hat_digit() { init_rayon_pool(); let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { - type Cfg = fp128::D64Dense; + type Cfg = fp128::Dense; const D: usize = Cfg::D; let (verifier_setup, commitment, proof, opening_point, opening, _layout, selection) = @@ -749,11 +749,11 @@ fn small_field_d64_dense_degenerate_roots_fail_fast() { } #[test] -fn dense_d64_tiny_roots_and_setup_capacities_are_rejected() { +fn adaptive_dense_tiny_roots_and_setup_capacities_are_rejected() { init_rayon_pool(); let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { - type Cfg = fp128::D64Dense; + type Cfg = fp128::Dense; let nv = 4; let err = Cfg::runtime_schedule(AkitaScheduleLookupKey::single( PolynomialGroupLayout::singleton(nv), @@ -773,11 +773,11 @@ fn dense_d64_tiny_roots_and_setup_capacities_are_rejected() { } #[test] -fn dense_d64_adaptive_mixed_basis_roundtrip_and_serialization() { +fn adaptive_dense_mixed_basis_roundtrip_and_serialization() { init_rayon_pool(); let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { - type Cfg = fp128::D64Dense; + type Cfg = fp128::Dense; const D: usize = Cfg::D; let nv = DENSE_TEST_NV; @@ -830,13 +830,13 @@ fn adaptive_onehot_direct_tail_uses_terminal_schedule_basis() { init_rayon_pool(); let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { - type Cfg = fp128::D64OneHot; - const D: usize = Cfg::D; + type Cfg = fp128::OneHot; let nv = ONEHOT_TEST_NV; let layout = singleton_layout::(nv); + let root_d = layout.d_a(); let total_field = (layout.num_live_blocks * layout.num_positions_per_block) - .checked_mul(D) + .checked_mul(root_d) .expect("total field size overflow"); let total_chunks = total_field / ONEHOT_K; assert_eq!(total_chunks * ONEHOT_K, total_field); @@ -845,9 +845,9 @@ fn adaptive_onehot_direct_tail_uses_terminal_schedule_basis() { let indices: Vec> = (0..total_chunks) .map(|_| Some(rng.gen_range(0..ONEHOT_K))) .collect(); - let onehot_poly = OneHotPoly::::new(ONEHOT_K, D, indices).unwrap(); + let onehot_poly = OneHotPoly::::new(ONEHOT_K, root_d, indices).unwrap(); let pt = random_point::(nv); - let expected_opening = opening_from_poly::(&onehot_poly, &pt, &layout); + let expected_opening = opening_from_poly_for_layout(&onehot_poly, &pt, &layout); #[cfg(feature = "disk-persistence")] purge_setup_cache(nv); @@ -929,16 +929,15 @@ fn batched_onehot_same_point_round_trip() { init_rayon_pool(); let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { - // NV=20 is large enough to include a recursive suffix, while the - // two-claim opening batch still misses singleton/4-batch generated tables - // and routes through the planner DP fallback in `runtime_schedule`. - type Cfg = fp128::D64OneHot; - const D: usize = Cfg::D; + // NV=20 is large enough to include a recursive suffix in the generated + // adaptive two-claim schedule. + type Cfg = fp128::OneHot; const NV: usize = 20; let nv = NV; let opening_batch = akita_types::OpeningClaimsLayout::new(nv, 2).expect("opening_batch"); let layout = Cfg::get_params_for_batched_commitment(&opening_batch).expect("layout"); + let root_d = layout.d_a(); let plan = Cfg::runtime_schedule(AkitaScheduleLookupKey::single( PolynomialGroupLayout::singleton(NV), )) @@ -957,7 +956,7 @@ fn batched_onehot_same_point_round_trip() { "fixture must cross a production fold with an exact partial final row" ); let total_field = (layout.num_live_blocks * layout.num_positions_per_block) - .checked_mul(D) + .checked_mul(root_d) .expect("total field size overflow"); let total_chunks = total_field / ONEHOT_K; assert_eq!(total_chunks * ONEHOT_K, total_field); @@ -970,13 +969,13 @@ fn batched_onehot_same_point_round_trip() { let indices_b: Vec> = (0..total_chunks) .map(|_| Some(rng_b.gen_range(0..ONEHOT_K))) .collect(); - let poly_a = OneHotPoly::::new(ONEHOT_K, D, indices_a).unwrap(); - let poly_b = OneHotPoly::::new(ONEHOT_K, D, indices_b).unwrap(); + let poly_a = OneHotPoly::::new(ONEHOT_K, root_d, indices_a).unwrap(); + let poly_b = OneHotPoly::::new(ONEHOT_K, root_d, indices_b).unwrap(); let poly_group = [&poly_a, &poly_b]; let pt = random_point(nv); let openings = [ - opening_from_poly::(&poly_a, &pt, &layout), - opening_from_poly::(&poly_b, &pt, &layout), + opening_from_poly_for_layout(&poly_a, &pt, &layout), + opening_from_poly_for_layout(&poly_b, &pt, &layout), ]; #[cfg(feature = "disk-persistence")] @@ -1071,14 +1070,14 @@ fn batched_onehot_same_point_rejects_tampered_root_stage1_range_image_evaluation init_rayon_pool(); let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { - type Cfg = fp128::D64OneHot; - const D: usize = Cfg::D; + type Cfg = fp128::OneHot; let nv = ONEHOT_TEST_NV; let layout = akita_batched_root_layout::(nv, SAME_POINT_ONEHOT_BATCH_SIZE).expect("layout"); + let root_d = layout.d_a(); let total_field = (layout.num_live_blocks * layout.num_positions_per_block) - .checked_mul(D) + .checked_mul(root_d) .expect("total field size overflow"); let total_chunks = total_field / ONEHOT_K; assert_eq!(total_chunks * ONEHOT_K, total_field); @@ -1089,14 +1088,14 @@ fn batched_onehot_same_point_rejects_tampered_root_stage1_range_image_evaluation let indices: Vec> = (0..total_chunks) .map(|_| Some(rng.gen_range(0..ONEHOT_K))) .collect(); - OneHotPoly::::new(ONEHOT_K, D, indices).unwrap() + OneHotPoly::::new(ONEHOT_K, root_d, indices).unwrap() }) .collect(); let poly_group: Vec<&OneHotPoly> = polys.iter().collect(); let pt = random_point(nv); let openings: Vec = polys .iter() - .map(|poly| opening_from_poly::(poly, &pt, &layout)) + .map(|poly| opening_from_poly_for_layout(poly, &pt, &layout)) .collect(); #[cfg(feature = "disk-persistence")] diff --git a/crates/akita-pcs/tests/batched_aggregated_e2e.rs b/crates/akita-pcs/tests/batched_aggregated_e2e.rs index fe51a01be..d3bae13ba 100644 --- a/crates/akita-pcs/tests/batched_aggregated_e2e.rs +++ b/crates/akita-pcs/tests/batched_aggregated_e2e.rs @@ -34,12 +34,14 @@ use common::*; const DENSE_ONEHOT_K: usize = DENSE_D; fn make_dense_cfg_onehot_poly(layout: &CommittedGroupParams, seed: u64) -> OneHotPoly { - let total_ring = layout.num_live_blocks * layout.num_positions_per_block; + let root_d = layout.d_a(); + let total_field = layout.num_live_blocks * layout.num_positions_per_block * root_d; + assert!(total_field.is_multiple_of(DENSE_ONEHOT_K)); let mut rng = StdRng::seed_from_u64(seed); - let indices: Vec> = (0..total_ring) + let indices: Vec> = (0..total_field / DENSE_ONEHOT_K) .map(|_| Some(rng.gen_range(0..DENSE_ONEHOT_K) as u8)) .collect(); - OneHotPoly::::new(DENSE_ONEHOT_K, DENSE_D, indices) + OneHotPoly::::new(DENSE_ONEHOT_K, root_d, indices) .expect("onehot poly under dense config") } @@ -61,7 +63,7 @@ mod non_zk_aggregated_cases { let pt = random_point(nv, 0xf00d_0000 + nv as u64); let openings: Vec = polys .iter() - .map(|poly| opening_from_poly::(poly, &pt, &layout)) + .map(|poly| opening_from_poly_for_layout(poly, &pt, &layout)) .collect(); let setup = AkitaCommitmentScheme::::setup_prover(nv, batch_size).unwrap(); @@ -152,7 +154,7 @@ mod non_zk_aggregated_cases { let pt = random_point(nv, 0xaaaa_0000 + nv as u64); let openings: Vec = polys .iter() - .map(|poly| opening_from_poly::(poly, &pt, &layout)) + .map(|poly| opening_from_poly_for_layout(poly, &pt, &layout)) .collect(); let setup = AkitaCommitmentScheme::::setup_prover(nv, batch_size).unwrap(); @@ -275,7 +277,7 @@ fn aggregated_mixed_dense_and_onehot_under_dense_cfg() { let pt = random_point(NV, 0x4d10_ffff); let openings: Vec = polys .iter() - .map(|poly| opening_from_poly::(poly, &pt, &layout)) + .map(|poly| opening_from_poly_for_layout(poly, &pt, &layout)) .collect(); let setup = AkitaCommitmentScheme::::setup_prover(NV, BATCH_SIZE).unwrap(); diff --git a/crates/akita-pcs/tests/common/mod.rs b/crates/akita-pcs/tests/common/mod.rs index 429f9257a..bc6b3eadb 100644 --- a/crates/akita-pcs/tests/common/mod.rs +++ b/crates/akita-pcs/tests/common/mod.rs @@ -37,14 +37,14 @@ pub(super) const STACK_SIZE: usize = 256 * 1024 * 1024; // Bare presets: test-only non-singleton batched opening shapes // fall through to the offline DP planner on table miss via the default // `runtime_schedule` fallback. -pub(super) type OneHotCfg = fp128::D64OneHot; +pub(super) type OneHotCfg = fp128::OneHot; pub(super) const ONEHOT_D: usize = OneHotCfg::D; -// `fp128::D64OneHot` requires K=256 one-hot schedules (chunks span `K/D = 4` +// `fp128::OneHot` requires K=256 one-hot schedules // ring elements), so the committed poly has `2^nv / K` chunks, not one chunk // per ring element. pub(super) const ONEHOT_K: usize = 256; -pub(super) type DenseCfg = fp128::D64Dense; +pub(super) type DenseCfg = fp128::Dense; pub(super) const DENSE_D: usize = DenseCfg::D; static INIT_RAYON: Once = Once::new(); @@ -291,6 +291,30 @@ where opening_from_poly_with_basis::(poly, point, layout, BasisMode::Lagrange) } +pub(super) fn opening_from_poly_for_layout<'a, P>( + poly: &'a P, + point: &[F], + layout: &CommittedGroupParams, +) -> F +where + P: RootOpeningSource + + RootPolyShape + + RootOpeningSource + + RootPolyShape + + RootOpeningSource + + RootPolyShape, + CpuBackend: OpeningFoldKernel<

>::OpeningView<'a>, F, 64> + + OpeningFoldKernel<

>::OpeningView<'a>, F, 128> + + OpeningFoldKernel<

>::OpeningView<'a>, F, 256>, +{ + match layout.d_a() { + 64 => opening_from_poly::<64, _>(poly, point, layout), + 128 => opening_from_poly::<128, _>(poly, point, layout), + 256 => opening_from_poly::<256, _>(poly, point, layout), + dimension => panic!("unsupported test opening ring dimension D={dimension}"), + } +} + pub(super) fn opening_from_poly_with_basis<'a, const D: usize, P>( poly: &'a P, point: &[F], @@ -342,13 +366,14 @@ where pub(super) fn make_onehot_poly(layout: &CommittedGroupParams, seed: u64) -> OneHotPoly { // `2^nv = (num_live_blocks · num_positions_per_block) · D` field elements, grouped into // `2^nv / K` one-hot chunks of size `K`. - let total_field = layout.num_live_blocks * layout.num_positions_per_block * ONEHOT_D; + let root_d = layout.d_a(); + let total_field = layout.num_live_blocks * layout.num_positions_per_block * root_d; let total_chunks = total_field / ONEHOT_K; let mut rng = StdRng::seed_from_u64(seed); let indices: Vec> = (0..total_chunks) .map(|_| Some(rng.gen_range(0..ONEHOT_K) as u8)) .collect(); - OneHotPoly::::new(ONEHOT_K, ONEHOT_D, indices).expect("onehot poly") + OneHotPoly::::new(ONEHOT_K, root_d, indices).expect("onehot poly") } pub(super) fn make_dense_poly(nv: usize, seed: u64) -> DensePoly { @@ -500,15 +525,13 @@ pub(super) fn recursive_multi_group_round_trip( .map(|polys| { polys .iter() - .map(|poly| { - opening_from_poly::(poly, &point[..PRE_NV], &pre_layout) - }) + .map(|poly| opening_from_poly_for_layout(poly, &point[..PRE_NV], &pre_layout)) .collect() }) .collect(); let final_openings: Vec = final_polys .iter() - .map(|poly| opening_from_poly::(poly, &point, root_params)) + .map(|poly| opening_from_poly_for_layout(poly, &point, root_params)) .collect(); let pre_refs_by_group: Vec>> = pre_polys_by_group @@ -620,8 +643,11 @@ pub(super) fn recursive_multi_group_round_trip( BasisMode::Lagrange, ); assert!( - matches!(result, Err(AkitaError::InvalidProof)), - "{label} must return InvalidProof without panicking, got {result:?}" + matches!( + result, + Err(AkitaError::InvalidProof | AkitaError::InvalidInput(_)) + ), + "{label} must return a proof/input rejection without panicking, got {result:?}" ); }; diff --git a/crates/akita-pcs/tests/distributed_setup_offload_e2e.rs b/crates/akita-pcs/tests/distributed_setup_offload_e2e.rs index a848fbe40..37e3f0566 100644 --- a/crates/akita-pcs/tests/distributed_setup_offload_e2e.rs +++ b/crates/akita-pcs/tests/distributed_setup_offload_e2e.rs @@ -1,8 +1,8 @@ //! End-to-end coverage for the mixed distributed (multi-chunk) + recursive //! setup-offload profile. //! -//! This test uses `RecursiveCommitmentConfig` (the -//! production `W8R2` preset, `fp128_d64_onehot_recursive_multi_chunk_w8r2` +//! This test uses `RecursiveCommitmentConfig` (the +//! production `W8R2` preset, `fp128_onehot_recursive_multi_chunk_w8r2` //! family): two precommitted singleton groups at `nv=16` and a two-polynomial //! final group at `nv=32`. That schedule combines the `W8R2` chunked witness //! layout (8 chunks on the two leading fold levels) with recursive setup @@ -24,15 +24,15 @@ use akita_config::proof_optimized::fp128; use akita_config::{CommitmentConfig, PrecommittedCommitmentConfig, RecursiveCommitmentConfig}; use akita_types::{ setup_matrix_capacity_for_schedule, verifier_setup_matrix_capacity_for_schedule, - AkitaScheduleLookupKey, CommittedGroupProfile, FoldSchedule, OpeningClaimsLayout, - PolynomialGroupLayout, SetupContributionMode, + AkitaScheduleLookupKey, CommitmentRingDims, CommittedGroupProfile, FoldSchedule, + OpeningClaimsLayout, PolynomialGroupLayout, SetupContributionMode, }; use common::*; const TRANSCRIPT_DOMAIN: &[u8] = b"distributed_setup_offload_e2e/w8r2"; -type W8R2Cfg = RecursiveCommitmentConfig; -type W8R2PrecommittedCfg = PrecommittedCommitmentConfig; +type W8R2Cfg = RecursiveCommitmentConfig; +type W8R2PrecommittedCfg = PrecommittedCommitmentConfig; fn w8r2_profiling_key() -> AkitaScheduleLookupKey { let pre_group = PolynomialGroupLayout::new(16, 1); @@ -76,13 +76,13 @@ fn w8r2_verifier_setup_stops_after_the_offloaded_chain() { ); assert_eq!( &incoming_prefixes[..2], - &[Some(28_180_480), Some(20_447_232)] + &[Some(12_681_216), Some(7_840_768)] ); assert!(incoming_prefixes[2..].iter().all(Option::is_none)); - assert_eq!(prover.num_field_elements, 28_180_480); - assert_eq!(verifier.num_field_elements, 10_223_616); - assert_eq!(setup_for_two.num_field_elements, 112_721_920); - assert_eq!(setup_for_four.num_field_elements, 225_443_840); + assert_eq!(prover.num_field_elements, 12_681_216); + assert_eq!(verifier.num_field_elements, 5_046_272); + assert_eq!(setup_for_two.num_field_elements, 8_388_608); + assert_eq!(setup_for_four.num_field_elements, 12_681_216); } /// Assert the exact shipped `W8R2` profile shape, not just "some mixed fold". @@ -91,13 +91,33 @@ fn w8r2_verifier_setup_stops_after_the_offloaded_chain() { /// the test pins every distinguishing fact. This catches `W4R2` vs `W8R2`, a /// level-0/level-1 mode swap, only one mixed leading fold, and a missing/extra /// setup-prefix handoff — none of which a bare "any chunked recursive fold" check -/// would detect. `D64OneHot` (single-chunk) also fails this on levels 0/1. +/// would detect. The single-chunk profile also fails this on levels 0/1. fn assert_w8r2_profile_shape(schedule: &FoldSchedule) { assert!( schedule.recursive_folds.len() >= 2, "W8R2 profile must have at least three fold levels, got {}", 1 + schedule.recursive_folds.len() ); + assert_eq!( + schedule.root.params.final_group.commitment.role_dims(), + CommitmentRingDims { + inner: 256, + outer: 128, + opening: 64, + } + ); + assert_eq!( + schedule.recursive_folds[0].params.witness.role_dims(), + CommitmentRingDims { + inner: 256, + outer: 128, + opening: 64, + } + ); + assert_eq!( + schedule.recursive_folds[1].params.witness.role_dims(), + CommitmentRingDims::uniform(64) + ); // Levels 0 and 1: both chunked W8R2 (8 chunks over 2 leading levels) AND both // running the Stage-3 setup-product sum-check (`Recursive`). @@ -162,7 +182,7 @@ fn assert_w8r2_profile_shape(schedule: &FoldSchedule) { #[test] #[ignore = "production-sized profile E2E; run explicitly with --release"] fn mix_multi_chunk_recursive_profile_proves_and_verifies() { - recursive_multi_group_round_trip::( + recursive_multi_group_round_trip::( TRANSCRIPT_DOMAIN, assert_w8r2_profile_shape, ); diff --git a/crates/akita-pcs/tests/heterogeneous_prove_e2e.rs b/crates/akita-pcs/tests/heterogeneous_prove_e2e.rs index 8487dfb13..6520a1664 100644 --- a/crates/akita-pcs/tests/heterogeneous_prove_e2e.rs +++ b/crates/akita-pcs/tests/heterogeneous_prove_e2e.rs @@ -16,7 +16,7 @@ mod common; use common::selected_prover_data; use std::any::TypeId; -type Cfg = fp128::D64Dense; +type Cfg = fp128::Dense; type F = fp128::Field; const D: usize = Cfg::D; type Scheme = AkitaCommitmentScheme; diff --git a/crates/akita-pcs/tests/recursive_setup_e2e.rs b/crates/akita-pcs/tests/recursive_setup_e2e.rs index fbccd2bb4..00bbe35c5 100644 --- a/crates/akita-pcs/tests/recursive_setup_e2e.rs +++ b/crates/akita-pcs/tests/recursive_setup_e2e.rs @@ -1,7 +1,7 @@ //! End-to-end coverage for the generated recursive setup-offload profile. //! //! This test intentionally uses the profile emitted in -//! `fp128_d64_onehot_recursive`: two precommitted singleton groups at `nv=16` +//! `fp128_onehot_recursive`: two precommitted singleton groups at `nv=16` //! and a two-polynomial final group at `nv=32`. That generated schedule carries //! setup-prefix metadata, so a successful recursive proof exercises the //! offloaded setup-contribution path rather than the inline direct setup scan. @@ -26,5 +26,5 @@ fn generated_recursive_onehot_profile_proves_with_setup_offload() { // Single-chunk base: the shared round-trip already asserts the setup-prefix // metadata and stage-3 setup sumcheck, so no profile-specific schedule check // is needed here. - recursive_multi_group_round_trip::(TRANSCRIPT_DOMAIN, |_schedule| {}); + recursive_multi_group_round_trip::(TRANSCRIPT_DOMAIN, |_schedule| {}); } diff --git a/crates/akita-pcs/tests/setup.rs b/crates/akita-pcs/tests/setup.rs index beaa081d4..895e60a68 100644 --- a/crates/akita-pcs/tests/setup.rs +++ b/crates/akita-pcs/tests/setup.rs @@ -30,7 +30,7 @@ use akita_prover::{ComputeBackendSetup, CpuBackend}; use akita_transcript::AkitaTranscript; use akita_types::{AkitaBatchedProof, BasisMode, SetupMatrixCapacity}; use common::{ - dense_field_evals, init_rayon_pool, opening_from_poly, prove_input, random_point, + dense_field_evals, init_rayon_pool, opening_from_poly_for_layout, prove_input, random_point, run_on_large_stack, verify_input, F, }; use rand::rngs::StdRng; @@ -115,12 +115,13 @@ where akita_types::OpeningClaimsLayout::new(poly_nv, 1).expect("singleton opening batch"); let layout = Cfg::get_params_for_batched_commitment(&opening_layout).expect("layout"); let schedule = Cfg::get_params_for_prove(&opening_layout).expect("schedule"); + let root_d = layout.d_a(); let evals = dense_field_evals(poly_nv, 0xdead_beef_0000 + poly_nv as u64); - let poly = DensePoly::::from_field_evals(poly_nv, D, &evals).expect("dense poly"); + let poly = DensePoly::::from_field_evals(poly_nv, root_d, &evals).expect("dense poly"); let pt = random_point(poly_nv, 0xcafe_0000 + poly_nv as u64); - let expected_opening = opening_from_poly::(&poly, &pt, &layout); + let expected_opening = opening_from_poly_for_layout(&poly, &pt, &layout); let setup = AkitaCommitmentScheme::::setup_prover(setup_nv, setup_polys).unwrap(); let prepared = CpuBackend.prepare_setup(&setup).unwrap(); @@ -218,20 +219,21 @@ where akita_types::OpeningClaimsLayout::new(poly_nv, 1).expect("singleton opening batch"); let layout = Cfg::get_params_for_batched_commitment(&opening_layout).expect("layout"); let schedule = Cfg::get_params_for_prove(&opening_layout).expect("schedule"); + let root_d = layout.d_a(); let k = 256; let total_ring = layout.num_live_blocks * layout.num_positions_per_block; assert_eq!( - total_ring * D, + total_ring * root_d, 1usize << poly_nv, "onehot layout mismatch at nv={poly_nv}" ); - let total_chunks = total_ring * D / k; + let total_chunks = total_ring * root_d / k; let mut rng = StdRng::seed_from_u64(0xdead_beef_0001 + poly_nv as u64); let indices: Vec> = (0..total_chunks) .map(|_| Some(rng.gen_range(0..k))) .collect(); - let poly = OneHotPoly::::new(k, D, indices.clone()).expect("onehot poly"); + let poly = OneHotPoly::::new(k, root_d, indices.clone()).expect("onehot poly"); let pt = random_point(poly_nv, 0xcafe_0001 + poly_nv as u64); let expected_opening = onehot_lagrange_opening(&indices, k, &pt); @@ -354,24 +356,24 @@ fn run_dense_batched_e2e( assert_eq!(Cfg::D, D); assert!(commit_batch >= 1); - let layout = Cfg::get_params_for_batched_commitment( - &akita_types::OpeningClaimsLayout::new(poly_nv, 1).expect("singleton opening batch"), - ) - .expect("layout"); + let layout = + akita_config::test_support::akita_batched_root_layout::(poly_nv, commit_batch) + .expect("batched layout"); + let root_d = layout.d_a(); let polys: Vec> = (0..commit_batch) .map(|idx| { let mut rng = StdRng::seed_from_u64(0xbeef_cafe_0000 + idx as u64); let evals: Vec = (0..1usize << poly_nv) .map(|_| F::from_canonical_u128_reduced(rng.gen::())) .collect(); - DensePoly::::from_field_evals(poly_nv, D, &evals).expect("dense poly") + DensePoly::::from_field_evals(poly_nv, root_d, &evals).expect("dense poly") }) .collect(); let pt = random_point(poly_nv, 0xbabe_0000 + poly_nv as u64); let openings: Vec = polys .iter() - .map(|poly| opening_from_poly::(poly, &pt, &layout)) + .map(|poly| opening_from_poly_for_layout(poly, &pt, &layout)) .collect(); let setup = AkitaCommitmentScheme::::setup_prover(setup_nv, setup_polys).unwrap(); @@ -418,12 +420,9 @@ fn run_dense_batched_e2e( /// Batched onehot round-trip. /// -/// Important: onehot polys bake their `(block_index_bits, position_index_bits)` block split in at -/// construction time, unlike dense polys which rebuild blocks from the -/// prover-supplied `num_positions_per_block`. Under batched commits that split must match -/// the layout the prover will use, which is -/// `test_support::akita_batched_root_layout(nv, setup_polys)` — i.e., sized -/// for the setup's `max_num_batched_polys`, not for a lone poly. +/// The construction dimension is metadata rather than storage authority, but +/// it must still match the root layout so setup-capacity failures are tested +/// with a polynomial of exactly `poly_nv` variables. fn run_onehot_batched_e2e( setup_nv: usize, setup_polys: usize, @@ -439,10 +438,11 @@ fn run_onehot_batched_e2e( let layout = akita_config::test_support::akita_batched_root_layout::(poly_nv, commit_batch) .expect("batched layout"); + let root_d = layout.d_a(); let k = 256; let total_ring = layout.num_live_blocks * layout.num_positions_per_block; - assert_eq!(total_ring * D, 1usize << poly_nv); - let total_chunks = total_ring * D / k; + assert_eq!(total_ring * root_d, 1usize << poly_nv); + let total_chunks = total_ring * root_d / k; let (polys, onehot_indices): (Vec<_>, Vec<_>) = (0..commit_batch) .map(|idx| { @@ -450,7 +450,8 @@ fn run_onehot_batched_e2e( let indices: Vec> = (0..total_chunks) .map(|_| Some(rng.gen_range(0..k))) .collect(); - let poly = OneHotPoly::::new(k, D, indices.clone()).expect("onehot poly"); + let poly = + OneHotPoly::::new(k, root_d, indices.clone()).expect("onehot poly"); (poly, indices) }) .unzip(); @@ -592,27 +593,17 @@ macro_rules! preset_module { }; } -// Multipoint/batched setup sizing falls through to the planner DP via the -// default `runtime_schedule` fallback, so bare presets suffice — even -// tables-only configs (`D128*` has no table at all). -preset_module!( - d128_dense, - fp128::D128Dense, - 128, - run_dense_e2e, - run_dense_batched_e2e -); preset_module!( - d64_dense, - fp128::D64Dense, - 64, + adaptive_dense, + fp128::Dense, + 256, run_dense_e2e, run_dense_batched_e2e ); preset_module!( - d64_onehot, - fp128::D64OneHot, - 64, + adaptive_onehot, + fp128::OneHot, + 256, run_onehot_e2e, run_onehot_batched_e2e ); diff --git a/crates/akita-pcs/tests/single_poly_e2e.rs b/crates/akita-pcs/tests/single_poly_e2e.rs index d5a3a772c..376daaaee 100644 --- a/crates/akita-pcs/tests/single_poly_e2e.rs +++ b/crates/akita-pcs/tests/single_poly_e2e.rs @@ -5,13 +5,13 @@ //! //! Two polynomial representations are covered: //! -//! * **One-hot** — `fp128::D64OneHot` (D = 64, K = 256). -//! * **Dense** — `fp128::D128Dense` (D = 128, arbitrary field coefficients). +//! * **One-hot** — adaptive `fp128::OneHot` (K = 256). +//! * **Dense** — adaptive `fp128::Dense` (arbitrary field coefficients). //! //! Variable counts: //! //! - one-hot: 12, 15, 20 -//! - dense: 13, 15, 18 +//! - dense: 14, 16, 24 #![allow(missing_docs)] @@ -34,7 +34,8 @@ fn run_single_onehot(nv: usize) { &akita_types::OpeningClaimsLayout::new(nv, 1).expect("singleton opening batch"), ) .expect("layout"); - let total_field = layout.num_live_blocks * layout.num_positions_per_block * ONEHOT_D; + let root_d = layout.d_a(); + let total_field = layout.num_live_blocks * layout.num_positions_per_block * root_d; assert_eq!(total_field, 1usize << nv); let total_chunks = total_field / ONEHOT_K; @@ -42,10 +43,15 @@ fn run_single_onehot(nv: usize) { let indices: Vec> = (0..total_chunks) .map(|_| Some(rng.gen_range(0..ONEHOT_K) as u8)) .collect(); - let poly = OneHotPoly::::new(ONEHOT_K, ONEHOT_D, indices).expect("onehot poly"); + let poly = OneHotPoly::::new(ONEHOT_K, root_d, indices).expect("onehot poly"); let pt = random_point(nv, 0xcafe_0000 + nv as u64); - let expected_opening = opening_from_poly::(&poly, &pt, &layout); + let expected_opening = match root_d { + 64 => opening_from_poly::<64, _>(&poly, &pt, &layout), + 128 => opening_from_poly::<128, _>(&poly, &pt, &layout), + 256 => opening_from_poly::<256, _>(&poly, &pt, &layout), + _ => panic!("unsupported adaptive one-hot root dimension D{root_d}"), + }; let setup = AkitaCommitmentScheme::::setup_prover(nv, 1).unwrap(); let prepared = CpuBackend.prepare_setup(&setup).unwrap(); @@ -111,11 +117,10 @@ fn run_single_onehot(nv: usize) { } // --------------------------------------------------------------------------- -// Dense helpers (D = 128) +// Dense helpers (D = 64) // --------------------------------------------------------------------------- -type DenseCfg = fp128::D128Dense; -const DENSE_D: usize = DenseCfg::D; +type DenseCfg = fp128::Dense; fn run_single_dense(nv: usize) { init_rayon_pool(); @@ -124,12 +129,13 @@ fn run_single_dense(nv: usize) { &akita_types::OpeningClaimsLayout::new(nv, 1).expect("singleton opening batch"), ) .expect("layout"); + let root_d = layout.d_a(); let evals = dense_field_evals(nv, 0xface_feed_0000 + nv as u64); - let poly = DensePoly::::from_field_evals(nv, DENSE_D, &evals).expect("dense poly"); + let poly = DensePoly::::from_field_evals(nv, root_d, &evals).expect("dense poly"); let pt = random_point(nv, 0xbabe_0000 + nv as u64); - let expected_opening = opening_from_poly::(&poly, &pt, &layout); + let expected_opening = opening_from_poly_for_layout(&poly, &pt, &layout); let setup = AkitaCommitmentScheme::::setup_prover(nv, 1).unwrap(); let commit_prepared = CpuBackend.prepare_setup(&setup).unwrap(); @@ -254,18 +260,18 @@ fn single_onehot_nv20() { // --------------------------------------------------------------------------- #[test] -fn single_dense_nv13() { - run_single_dense(13); +fn single_dense_nv14() { + run_single_dense(14); } #[test] -fn single_dense_nv15() { - run_single_dense(15); +fn single_dense_nv16() { + run_single_dense(16); } #[test] -fn single_dense_nv18() { - run_single_dense(18); +fn single_dense_nv24() { + run_single_dense(24); } // #[test] @@ -285,7 +291,8 @@ fn run_single_onehot_oversized_setup(setup_nv: usize, poly_nv: usize) { &akita_types::OpeningClaimsLayout::new(poly_nv, 1).expect("singleton opening batch"), ) .expect("layout"); - let total_field = layout.num_live_blocks * layout.num_positions_per_block * ONEHOT_D; + let root_d = layout.d_a(); + let total_field = layout.num_live_blocks * layout.num_positions_per_block * root_d; assert_eq!(total_field, 1usize << poly_nv); let total_chunks = total_field / ONEHOT_K; @@ -293,10 +300,15 @@ fn run_single_onehot_oversized_setup(setup_nv: usize, poly_nv: usize) { let indices: Vec> = (0..total_chunks) .map(|_| Some(rng.gen_range(0..ONEHOT_K) as u8)) .collect(); - let poly = OneHotPoly::::new(ONEHOT_K, ONEHOT_D, indices).expect("onehot poly"); + let poly = OneHotPoly::::new(ONEHOT_K, root_d, indices).expect("onehot poly"); let pt = random_point(poly_nv, 0xcafe_0000 + poly_nv as u64); - let expected_opening = opening_from_poly::(&poly, &pt, &layout); + let expected_opening = match root_d { + 64 => opening_from_poly::<64, _>(&poly, &pt, &layout), + 128 => opening_from_poly::<128, _>(&poly, &pt, &layout), + 256 => opening_from_poly::<256, _>(&poly, &pt, &layout), + _ => panic!("unsupported adaptive one-hot root dimension D{root_d}"), + }; let setup = AkitaCommitmentScheme::::setup_prover(setup_nv, 1).unwrap(); let prepared = CpuBackend.prepare_setup(&setup).unwrap(); diff --git a/crates/akita-pcs/tests/support/mod.rs b/crates/akita-pcs/tests/support/mod.rs index 2a5f79e51..778214f09 100644 --- a/crates/akita-pcs/tests/support/mod.rs +++ b/crates/akita-pcs/tests/support/mod.rs @@ -126,6 +126,8 @@ where type ExtField = Envelope::ExtField; const D: usize = Envelope::D; + const RING_DIMENSION_SCHEDULE_MODE: akita_schedules::RingDimensionScheduleMode = + Envelope::RING_DIMENSION_SCHEDULE_MODE; fn decomposition() -> DecompositionParams { Envelope::decomposition() @@ -135,6 +137,9 @@ where Envelope::ring_challenge_config(d).or_else(|_| Final::ring_challenge_config(d)) } + fn selection_policy() -> akita_schedules::SelectionPolicyId { + Envelope::selection_policy() + } fn sis_modulus_profile() -> SisModulusProfileId { Envelope::sis_modulus_profile() } diff --git a/crates/akita-planner/README.md b/crates/akita-planner/README.md index 8bcf710e0..f016f46a4 100644 --- a/crates/akita-planner/README.md +++ b/crates/akita-planner/README.md @@ -227,9 +227,9 @@ of precommitted groups: ```bash cargo run --release -p akita-planner --features catalog-gen \ --bin gen_schedule_tables -- crates/akita-schedules/src/generated \ - --final-group fp128_d64_onehot:32:2 \ - --precommitted-group fp128_d64_onehot:16:1 \ - --precommitted-group fp128_d64_dense:15:2 + --final-group fp128_onehot:32:2 \ + --precommitted-group fp128_onehot:16:1 \ + --precommitted-group fp128_dense:15:2 ``` The explicit flags are: @@ -245,9 +245,9 @@ Each numeric slot accepts either a single value or an inclusive range written as ```bash cargo run --release -p akita-planner --features catalog-gen \ --bin gen_schedule_tables -- crates/akita-schedules/src/generated \ - --final-group fp128_d64_onehot:30..=32:2..=4 \ - --precommitted-group fp128_d64_onehot:14..=16:1 \ - --precommitted-group fp128_d64_dense:15:1..=2 + --final-group fp128_onehot:30..=32:2..=4 \ + --precommitted-group fp128_onehot:14..=16:1 \ + --precommitted-group fp128_dense:15:1..=2 ``` The generator expands the cartesian product of the final-group range and every diff --git a/crates/akita-planner/examples/mixed_dimension_search.rs b/crates/akita-planner/examples/mixed_dimension_search.rs index 313aae4cb..46c065c5b 100644 --- a/crates/akita-planner/examples/mixed_dimension_search.rs +++ b/crates/akita-planner/examples/mixed_dimension_search.rs @@ -1,10 +1,8 @@ use akita_config::{ - policy_of, - proof_optimized::fp128::{D64OneHot, MixedDimFp128OneHot}, - CommitmentConfig, RecursiveCommitmentConfig, + policy_of, proof_optimized::fp128::OneHot, CommitmentConfig, RecursiveCommitmentConfig, }; -use akita_planner::find_schedule; -use akita_types::{AkitaScheduleLookupKey, CommittedGroupProfile, PolynomialGroupLayout}; +use akita_planner::{derive_standalone_precommit_profile, find_schedule}; +use akita_types::{AkitaScheduleLookupKey, PolynomialGroupLayout}; fn print_schedule(label: &str, planned: &akita_types::PlannedFoldSchedule) { let schedule = &planned.schedule; @@ -78,71 +76,59 @@ fn main() -> Result<(), akita_field::AkitaError> { .nth(1) .and_then(|value| value.parse().ok()) .unwrap_or(36); - let direct_policy = policy_of::(); + let direct_policy = policy_of::(); let direct_key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::singleton(num_vars)); let direct = find_schedule( &direct_key, - MixedDimFp128OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &[], &direct_policy, - MixedDimFp128OneHot::ring_challenge_config, + OneHot::ring_challenge_config, )?; print_schedule( &format!("direct scalar mixed-D search (nv={num_vars})"), &direct, ); - type MixedRecursive = RecursiveCommitmentConfig; - let mixed_recursive_policy = policy_of::(); - let mixed_recursive_key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::new(32, 2)); - let mixed_recursive_error = find_schedule( - &mixed_recursive_key, - MixedRecursive::root_honest_fold_policy(), + type Recursive = RecursiveCommitmentConfig; + let recursive_policy = policy_of::(); + let scalar_recursive_key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::new(32, 2)); + let scalar_recursive_error = find_schedule( + &scalar_recursive_key, + Recursive::root_honest_fold_policy(), &[], - &mixed_recursive_policy, - MixedRecursive::ring_challenge_config, + &recursive_policy, + Recursive::ring_challenge_config, ) - .expect_err("mixed-D recursive planning is intentionally deferred"); - println!("recursive mixed-D planner deferred as expected: {mixed_recursive_error}"); + .expect_err("scalar recursive planning has no setup groups to offload"); + println!("scalar recursive request rejected as expected: {scalar_recursive_error}"); let precommit_layout = PolynomialGroupLayout::singleton(16); - let precommit_key = AkitaScheduleLookupKey::single(precommit_layout); - let precommit_policy = policy_of::(); - let precommit = find_schedule( - &precommit_key, - D64OneHot::root_honest_fold_policy(), - &[], - &precommit_policy, - D64OneHot::ring_challenge_config, - )?; - let descriptor = CommittedGroupProfile::from_params( + let descriptor = derive_standalone_precommit_profile( precommit_layout, - &precommit.schedule.root.params.final_group.commitment, - ); + &direct_policy, + OneHot::root_honest_fold_policy(), + OneHot::ring_challenge_config, + )?; let recursive_key = AkitaScheduleLookupKey { final_group: PolynomialGroupLayout::new(32, 2), precommitteds: vec![descriptor, descriptor], }; let precommitted_honest_fold_policies = vec![ - D64OneHot::root_honest_fold_policy(), - D64OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), ]; - type Recursive = RecursiveCommitmentConfig; - let recursive_policy = policy_of::(); - let preserved = find_schedule( + let adaptive_recursive = find_schedule( &recursive_key, Recursive::root_honest_fold_policy(), &precommitted_honest_fold_policies, &recursive_policy, Recursive::ring_challenge_config, )?; - println!("preserved recursive grouped planner:"); + print_schedule("adaptive recursive grouped planner", &adaptive_recursive); println!( - " setup={} D64 ring elements, proof={} bytes, levels={}, offload_edges={}", - preserved.estimate.estimated_num_setup_field_elements, - preserved.estimate.estimated_proof_payload_bytes()?, - preserved.schedule.recursive_folds.len() + 2, - preserved.estimate.selected_offload_edges, + " offload_edges={}", + adaptive_recursive.estimate.selected_offload_edges, ); Ok(()) } diff --git a/crates/akita-planner/src/emit/mod.rs b/crates/akita-planner/src/emit/mod.rs index c6e77e53d..fa1c5bbf4 100644 --- a/crates/akita-planner/src/emit/mod.rs +++ b/crates/akita-planner/src/emit/mod.rs @@ -501,19 +501,40 @@ fn emit_witness_chunk(cfg: akita_types::ChunkedWitnessCfg) -> String { } fn emit_identity_const(identity: &GeneratedScheduleCatalogIdentity) -> String { - let ring_dimension_candidates = identity - .ring_dimension_candidates - .iter() - .map(|dims| { - format!( - "CommitmentRingDims {{ inner: {}, outer: {}, opening: {} }}", - dims.d_a(), - dims.d_b(), - dims.d_d() - ) - }) - .collect::>() - .join(", "); + let (ring_dimension_policy_statics, ring_dimension_schedule_mode) = + match identity.ring_dimension_schedule_mode { + akita_schedules::RingDimensionScheduleMode::UniformDimension { ring_dimension } => ( + String::new(), + format!("RingDimensionScheduleMode::UniformDimension {{ ring_dimension: {ring_dimension} }}"), + ), + akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + } => { + let format_dimensions = |dimensions: &[usize]| dimensions.iter().map(usize::to_string).collect::>().join(", "); + ( + format!( + concat!( + "#[rustfmt::skip]\n", + "pub(crate) static CATALOG_POTENTIAL_A_DIMENSIONS: &[usize] = &[{}];\n", + "#[rustfmt::skip]\n", + "pub(crate) static CATALOG_POTENTIAL_B_DIMENSIONS: &[usize] = &[{}];\n", + "#[rustfmt::skip]\n", + "pub(crate) static CATALOG_POTENTIAL_D_DIMENSIONS: &[usize] = &[{}];\n", + ), + format_dimensions(potential_a_dimensions), + format_dimensions(potential_b_dimensions), + format_dimensions(potential_d_dimensions), + ), + format!( + "RingDimensionScheduleMode::AdaptiveDimension {{ num_search_levels: {num_search_levels}, uniform_suffix_dimension: {uniform_suffix_dimension}, potential_a_dimensions: CATALOG_POTENTIAL_A_DIMENSIONS, potential_b_dimensions: CATALOG_POTENTIAL_B_DIMENSIONS, potential_d_dimensions: CATALOG_POTENTIAL_D_DIMENSIONS }}" + ), + ) + } + }; let ring_dims: String = identity .ring_dimensions .iter() @@ -522,8 +543,7 @@ fn emit_identity_const(identity: &GeneratedScheduleCatalogIdentity) -> String { .join(", "); format!( concat!( - "#[rustfmt::skip]\n", - "pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[{ring_dimension_candidates}];\n", + "{ring_dimension_policy_statics}", "#[rustfmt::skip]\n", "pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[{ring_dims}];\n", "#[rustfmt::skip]\n", @@ -547,14 +567,15 @@ fn emit_identity_const(identity: &GeneratedScheduleCatalogIdentity) -> String { " basis_range: ({basis_min}, {basis_max}),\n", " witness_chunk: {witness_chunk},\n", " recursive_setup_planning: {recursive_setup_planning},\n", - " ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES,\n", + " ring_dimension_schedule_mode: {ring_dimension_schedule_mode},\n", " ring_dimensions: CATALOG_RING_DIMENSIONS,\n", " ring_challenge_config_digest: {ring_challenge_config_digest},\n", " key_count: {key_count},\n", " key_digest: {key_digest},\n", "}};\n", ), - ring_dimension_candidates = ring_dimension_candidates, + ring_dimension_policy_statics = ring_dimension_policy_statics, + ring_dimension_schedule_mode = ring_dimension_schedule_mode, ring_dims = ring_dims, family_name = identity.family_name, protocol_epoch = identity.protocol_epoch, @@ -704,7 +725,7 @@ pub fn emit_family_module(spec: &EmitSpec) -> Result { GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, \ CommitmentRingDims, PlannerCostModelId, PolynomialGroupLayout, CommittedGroupProfile, \ InnerCommitMatrixParams, OuterCommitMatrixParams, \ - CommitmentPayloadMode, SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest,\n}};" + CommitmentPayloadMode, RingDimensionScheduleMode, SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest,\n}};" ) .map_err(|e| e.to_string())?; writeln!(out).map_err(|e| e.to_string())?; @@ -746,6 +767,9 @@ pub fn emit_precommitted_profiles_module(spec: &EmitSpec) -> Result(key: PolynomialGroupLayout) -> Result(&AkitaScheduleLookupKey::single(key), &[]) } -/// Offline mixed-dimension regeneration for the catalog-backed fp128 profile. -fn regen_mixed_dim_fp128_onehot(key: PolynomialGroupLayout) -> Result { - type Cfg = fp128::MixedDimFp128OneHot; +/// Offline regeneration for the catalog-backed default fp128 onehot profile. +fn regen_fp128_onehot(key: PolynomialGroupLayout) -> Result { + type Cfg = fp128::OneHot; let policy = policy_of::(); Ok(find_schedule( &AkitaScheduleLookupKey::single(key), @@ -262,6 +238,19 @@ fn regen_mixed_dim_fp128_onehot(key: PolynomialGroupLayout) -> Result Result { + type Cfg = fp128::Dense; + Ok(find_schedule( + &AkitaScheduleLookupKey::single(key), + honest_fold_policy_of::(), + &[], + &policy_of::(), + Cfg::ring_challenge_config, + )? + .schedule) +} + /// Pure multi-group DP regeneration for `Cfg` — never consults the generated table. fn regen_group_batch( key: AkitaScheduleLookupKey, @@ -376,25 +365,27 @@ fn precommitted_profiles( } } - if std::any::TypeId::of::() == std::any::TypeId::of::() - || std::any::TypeId::of::() == std::any::TypeId::of::() + if std::any::TypeId::of::() == std::any::TypeId::of::() + || std::any::TypeId::of::() == std::any::TypeId::of::() { push_unique_profile( &mut profiles, standalone_precommit_profile::(PolynomialGroupLayout::new(16, 1))?, ); + } + if std::any::TypeId::of::() == std::any::TypeId::of::() { push_unique_profile( &mut profiles, standalone_precommit_profile::(PolynomialGroupLayout::new(15, 2))?, ); } - if std::any::TypeId::of::() == std::any::TypeId::of::() { + if std::any::TypeId::of::() == std::any::TypeId::of::() { push_unique_profile( &mut profiles, standalone_precommit_profile::(PolynomialGroupLayout::new(20, 1))?, ); } - if std::any::TypeId::of::() == std::any::TypeId::of::() { + if std::any::TypeId::of::() == std::any::TypeId::of::() { push_unique_profile( &mut profiles, standalone_precommit_profile::(PolynomialGroupLayout::new(15, 2))?, @@ -417,7 +408,6 @@ fn group_batch_keys( direct.sort_by(|left, right| runtime_schedule_key_cmp(&left.0, &right.0)); return Ok(direct); } - let mut keys = supported_group_batch_keys::(direct)?; keys.sort_by(|left, right| runtime_schedule_key_cmp(&left.0, &right.0)); Ok(keys) @@ -425,14 +415,25 @@ fn group_batch_keys( fn direct_profile_group_batch_keys_for_cfg( ) -> Result)>, AkitaError> { - if std::any::TypeId::of::() == std::any::TypeId::of::() { - let mut keys = recursive_d64_onehot_profile_keys::()?; - keys.push(heterogeneous_d64_onehot_catalog_key()?); - keys.extend(onehot_group_batch_test_keys::()?); + if std::any::TypeId::of::() == std::any::TypeId::of::() { + let mut keys = recursive_onehot_profile_keys::()?; + keys.push(heterogeneous_onehot_catalog_key()?); + keys.extend(onehot_group_batch_test_keys::()?); return Ok(keys); } - if std::any::TypeId::of::() == std::any::TypeId::of::() { - return recursive_d64_onehot_profile_keys::(); + if std::any::TypeId::of::() == std::any::TypeId::of::() { + return recursive_onehot_profile_keys::(); + } + if std::any::TypeId::of::() == std::any::TypeId::of::() { + let group = PolynomialGroupLayout::new(14, 1); + let precommitted = standalone_precommit_profile::(group)?; + return Ok(vec![( + AkitaScheduleLookupKey { + final_group: group, + precommitteds: vec![precommitted], + }, + vec![honest_fold_policy_of::()], + )]); } Ok(Vec::new()) } @@ -446,19 +447,19 @@ fn recursive_profile_group_batch_keys( fn recursive_profile_group_batch_keys_for_recursive_cfg( ) -> Result)>, AkitaError> { if std::any::TypeId::of::() - == std::any::TypeId::of::>() + == std::any::TypeId::of::>() { - return recursive_d64_onehot_profile_keys::(); + return recursive_onehot_profile_keys::(); } if std::any::TypeId::of::() - == std::any::TypeId::of::>() + == std::any::TypeId::of::>() { - return recursive_d64_onehot_profile_keys::(); + return recursive_onehot_profile_keys::(); } Ok(Vec::new()) } -fn recursive_d64_onehot_profile_keys( +fn recursive_onehot_profile_keys( ) -> Result)>, AkitaError> { let precommitted_group = PolynomialGroupLayout::new(16, 1); let precommitted = standalone_precommit_profile::(precommitted_group)?; @@ -474,14 +475,14 @@ fn recursive_d64_onehot_profile_keys( )]) } -fn heterogeneous_d64_onehot_catalog_key( +fn heterogeneous_onehot_catalog_key( ) -> Result<(AkitaScheduleLookupKey, Vec), AkitaError> { let onehot_group = PolynomialGroupLayout::new(14, 1); let dense_group = PolynomialGroupLayout::new(15, 2); - let onehot_policy = honest_fold_policy_of::(); - let dense_policy = honest_fold_policy_of::(); - let onehot = standalone_precommit_profile::(onehot_group)?; - let dense = standalone_precommit_profile::(dense_group)?; + let onehot_policy = honest_fold_policy_of::(); + let dense_policy = honest_fold_policy_of::(); + let onehot = standalone_precommit_profile::(onehot_group)?; + let dense = standalone_precommit_profile::(dense_group)?; Ok(( AkitaScheduleLookupKey { final_group: PolynomialGroupLayout::new(16, 1), @@ -629,7 +630,11 @@ macro_rules! family_row { table_backed: table_backed::<$cfg>, policy: family_policy::<$cfg>, ring_challenge_config: <$cfg as CommitmentConfig>::ring_challenge_config, - precommitted_profiles: precommitted_profiles::<$cfg>, + // Standalone precommits are made under the base commitment + // configuration. Adaptive base configs are catalog-only at + // runtime, so asking the recursive adapter to rediscover them + // during offline generation would leave this registry empty. + precommitted_profiles: precommitted_profiles::<$base_cfg>, explicit_precommitted_group: explicit_precommitted_group::<$base_cfg>, } }; @@ -715,113 +720,84 @@ fn explicit_precommitted_group( /// here; both the table emitter and the drift-guard test pick it up /// automatically. pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ - family_row!( - "fp128_d128_dense", - "FP128_D128_DENSE_SCHEDULES", - "fp128-d128-dense", - FP128_D128_DENSE_KEYS, - fp128::D128Dense - ), - family_row!( - group_batch, - "fp128_d128_onehot", - "FP128_D128_ONEHOT_SCHEDULES", - "fp128-d128-onehot", - FP128_D128_ONEHOT_KEYS, - fp128::D128OneHot - ), - family_row!( - group_batch, - "fp128_d64_onehot", - "FP128_D64_ONEHOT_SCHEDULES", - "fp128-d64-onehot", - FP128_D64_ONEHOT_KEYS, - fp128::D64OneHot - ), - family_row!( - "fp128_d256_onehot", - "FP128_D256_ONEHOT_SCHEDULES", - "fp128-d256-onehot", - FP128_D256_ONEHOT_KEYS, - fp128::D256OneHot - ), GeneratedFamily { - module_name: "fp128_mixed_dim_onehot", - const_name: "FP128_MIXED_DIM_ONEHOT_SCHEDULES", - schedule_feature: "fp128-mixed-dim-onehot", - scalar_keys: FP128_MIXED_DIM_ONEHOT_KEYS, - regen: regen_mixed_dim_fp128_onehot, - regen_group_batch: regen_group_batch::, - emit_group_batch: false, - group_batch_keys: group_batch_keys::, - table_backed: table_backed::, - policy: family_policy::, - ring_challenge_config: - ::ring_challenge_config, - precommitted_profiles: precommitted_profiles::, - explicit_precommitted_group: explicit_precommitted_group::, + module_name: "fp128_onehot", + const_name: "FP128_ONEHOT_SCHEDULES", + schedule_feature: "fp128-onehot", + scalar_keys: FP128_ONEHOT_KEYS, + regen: regen_fp128_onehot, + regen_group_batch: regen_group_batch::, + emit_group_batch: true, + group_batch_keys: group_batch_keys::, + table_backed: table_backed::, + policy: family_policy::, + ring_challenge_config: ::ring_challenge_config, + precommitted_profiles: precommitted_profiles::, + explicit_precommitted_group: explicit_precommitted_group::, }, family_row!( recursive, - "fp128_d64_onehot_recursive", - "FP128_D64_ONEHOT_RECURSIVE_SCHEDULES", - "fp128-d64-onehot-recursive", + "fp128_onehot_recursive", + "FP128_ONEHOT_RECURSIVE_SCHEDULES", + "fp128-onehot-recursive", &[], - RecursiveCommitmentConfig, - fp128::D64OneHot + RecursiveCommitmentConfig, + fp128::OneHot ), - // Recursive setup offloading combined with the 8-chunk (production - // distributed-prover) witness layout. `D64OneHotMultiChunk` is the W8R2 - // preset (8 chunks x 2 leading levels); shares the recursive profiling key. family_row!( recursive, - "fp128_d64_onehot_recursive_multi_chunk_w8r2", - "FP128_D64_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES", - "fp128-d64-onehot-recursive-multi-chunk-w8r2", + "fp128_onehot_recursive_multi_chunk_w8r2", + "FP128_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES", + "fp128-onehot-recursive-multi-chunk-w8r2", &[], - RecursiveCommitmentConfig, - fp128::D64OneHotMultiChunk - ), - family_row!( - "fp128_d64_dense", - "FP128_D64_DENSE_SCHEDULES", - "fp128-d64-dense", - FP128_D64_DENSE_KEYS, - fp128::D64Dense + RecursiveCommitmentConfig, + fp128::OneHotMultiChunk ), - // Multi-chunk (distributed-prover) companions of the D64 families. Same - // `(num_vars, num_polynomials)` keys as their siblings; schedules differ - // because the policy prices the chunked witness layout. + GeneratedFamily { + module_name: "fp128_dense", + const_name: "FP128_DENSE_SCHEDULES", + schedule_feature: "fp128-dense", + scalar_keys: FP128_DENSE_KEYS, + regen: regen_fp128_dense, + regen_group_batch: regen_group_batch::, + emit_group_batch: false, + group_batch_keys: group_batch_keys::, + table_backed: table_backed::, + policy: family_policy::, + ring_challenge_config: ::ring_challenge_config, + precommitted_profiles: precommitted_profiles::, + explicit_precommitted_group: explicit_precommitted_group::, + }, family_row!( group_batch, - "fp128_d64_onehot_multi_chunk", - "FP128_D64_ONEHOT_MULTI_CHUNK_SCHEDULES", - "fp128-d64-onehot-multi-chunk", - FP128_D64_ONEHOT_MULTI_CHUNK_KEYS, - fp128::D64OneHotMultiChunk + "fp128_onehot_multi_chunk", + "FP128_ONEHOT_MULTI_CHUNK_SCHEDULES", + "fp128-onehot-multi-chunk", + FP128_ONEHOT_MULTI_CHUNK_KEYS, + fp128::OneHotMultiChunk ), family_row!( group_batch, - "fp128_d64_onehot_multi_chunk_w2r2", - "FP128_D64_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES", - "fp128-d64-onehot-multi-chunk-w2r2", - FP128_D64_ONEHOT_MULTI_CHUNK_W2R2_KEYS, - fp128::D64OneHotMultiChunkW2R2 + "fp128_onehot_multi_chunk_w2r2", + "FP128_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES", + "fp128-onehot-multi-chunk-w2r2", + FP128_ONEHOT_MULTI_CHUNK_W2R2_KEYS, + fp128::OneHotMultiChunkW2R2 ), family_row!( group_batch, - "fp128_d64_onehot_multi_chunk_w4r2", - "FP128_D64_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES", - "fp128-d64-onehot-multi-chunk-w4r2", - FP128_D64_ONEHOT_MULTI_CHUNK_W4R2_KEYS, - fp128::D64OneHotMultiChunkW4R2 + "fp128_onehot_multi_chunk_w4r2", + "FP128_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES", + "fp128-onehot-multi-chunk-w4r2", + FP128_ONEHOT_MULTI_CHUNK_W4R2_KEYS, + fp128::OneHotMultiChunkW4R2 ), family_row!( - "fp128_d64_dense_multi_chunk", - "FP128_D64_DENSE_MULTI_CHUNK_SCHEDULES", - "fp128-d64-dense-multi-chunk", - FP128_D64_DENSE_MULTI_CHUNK_KEYS, - fp128::D64DenseMultiChunk + "fp128_dense_multi_chunk", + "FP128_DENSE_MULTI_CHUNK_SCHEDULES", + "fp128-dense-multi-chunk", + FP128_DENSE_MULTI_CHUNK_KEYS, + fp128::DenseMultiChunk ), family_row!( "fp64_d128_dense", diff --git a/crates/akita-planner/src/lib.rs b/crates/akita-planner/src/lib.rs index 9e5d91ce5..c9a7453ee 100644 --- a/crates/akita-planner/src/lib.rs +++ b/crates/akita-planner/src/lib.rs @@ -2,8 +2,8 @@ //! //! This crate is a **pure, `Cfg`-free DP library**. The DP entry point //! is [`find_schedule`], which runs an exhaustive dynamic program to -//! minimize proof size for a schedule lookup key. Every per-preset input is -//! carried by the plain-value [`PlannerPolicy`] plus a `ring_challenge_config` / +//! optimize a schedule lookup key under its catalog-bound selection policy. +//! Every per-preset input is carried by the plain-value [`PlannerPolicy`] plus a `ring_challenge_config` / //! ring-challenge closure, so the planner names no `CommitmentConfig` //! types and depends only on `akita-schedules` / `akita-types` / //! `akita-challenges` / `akita-field`. @@ -16,8 +16,9 @@ //! preset-free. pub use akita_schedules::{ - ChunkedWitnessCfg, DecompositionParams, PlannerCostModelId, PlannerPolicy, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, DEFAULT_SIS_SECURITY_POLICY, + ChunkedWitnessCfg, DecompositionParams, PlannerCostModelId, PlannerPolicy, + RingDimensionScheduleMode, SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, + DEFAULT_SIS_SECURITY_POLICY, }; pub mod emit; @@ -38,6 +39,4 @@ pub use emit::{ write_precommitted_profiles_module, EmitSpec, }; pub use planner::find_schedule; -pub use schedule_params::{ - derive_standalone_precommit_profile, suffix_opening_layout, RingDimensionSearchDomain, -}; +pub use schedule_params::{derive_standalone_precommit_profile, suffix_opening_layout}; diff --git a/crates/akita-planner/src/planner.rs b/crates/akita-planner/src/planner.rs index 93d88e5e8..3bb4c0b23 100644 --- a/crates/akita-planner/src/planner.rs +++ b/crates/akita-planner/src/planner.rs @@ -14,13 +14,11 @@ use akita_types::{ PrecommittedLevelParams, WitnessLayout, }; -use akita_schedules::planner_support::{projected_collision_role_price, sis_key_at_dimension}; +use akita_schedules::planner_support::{sis_key_at_dimension, RingDimensionCandidate}; use crate::schedule_params::{ - derive_optimal_suffix_schedule, materialize_candidate_schedule, mixed_search, - select_complete_candidate, validate_policy, RingChallengeConfigFn, RingDimensionSearchDomain, - ScheduleMemo, SuffixCtx, SuffixState, MIXED_SEARCH_FOLD_LEVELS, - MIXED_SEARCH_SUFFIX_RING_DIMENSION, + derive_optimal_suffix_schedule, materialize_candidate_schedule, select_complete_candidate, + RingChallengeConfigFn, ScheduleMemo, SuffixCtx, SuffixState, }; use crate::PlannerPolicy; @@ -182,7 +180,7 @@ fn materialize_precommitted_group_for_open_basis( struct MultiGroupRootCandidateCtx<'a> { policy: &'a PlannerPolicy, - dimensions: CommitmentRingDims, + dimensions: RingDimensionCandidate<'a>, ring_challenge_cfg: &'a SparseChallengeConfig, final_honest_fold_policy: HonestFoldPolicySpec, } @@ -262,16 +260,16 @@ pub(crate) fn root_level_candidates_for_basis( final_honest_fold_policy: HonestFoldPolicySpec, precommitted_honest_fold_policies: &[HonestFoldPolicySpec], policy: &PlannerPolicy, - dimensions: CommitmentRingDims, + dimensions: RingDimensionCandidate<'_>, ring_challenge_cfg: &SparseChallengeConfig, ring_challenge_config: &dyn Fn(usize) -> Result, root_input_witness_len: usize, candidate_log_basis: u32, require_witness_contraction: bool, ) -> Result, AkitaError> { - dimensions.validate_role_projection()?; + dimensions.validate()?; let field_bits = policy.decomposition.field_bits(); - let alpha = dimensions.d_a().trailing_zeros() as usize; + let alpha = dimensions.inner().trailing_zeros() as usize; let reduced_vars = key.final_group.num_vars().saturating_sub(alpha); if reduced_vars == 0 { return Err(AkitaError::UnsupportedSchedule(format!( @@ -296,12 +294,25 @@ pub(crate) fn root_level_candidates_for_basis( let max_block_index_bits: usize = (reduced_vars - 1).min(usize::BITS as usize - 1); let mut candidates = Vec::new(); + let shared_opening_ring_dimension = match dimensions { + RingDimensionCandidate::Fixed(value) => value.d_d(), + RingDimensionCandidate::Adaptive { .. } => dimensions.inner(), + }; + if precommitted_groups.iter().any(|group| { + !group + .layout + .inner_commit_matrix + .ring_dimension() + .is_multiple_of(shared_opening_ring_dimension) + }) { + return Ok(Vec::new()); + } let (candidate_precommitted_groups, candidate_precommitted_d_width) = precommitted_groups_for_open_basis( &precommitted_groups, policy, ring_challenge_config, - dimensions.d_d(), + shared_opening_ring_dimension, candidate_log_basis, )?; for block_index_bits in (min_block_index_bits..=max_block_index_bits).rev() { @@ -351,7 +362,7 @@ fn root_final_group_level_params_candidate( ) -> Result, AkitaError> { let policy = ctx.policy; let dimensions = ctx.dimensions; - let d_a = dimensions.d_a(); + let d_a = dimensions.inner(); let family = policy.sis_modulus_profile; let decomp = ctx.policy.decomposition; let level_decomp = DecompositionParams { @@ -427,11 +438,9 @@ fn root_final_group_level_params_candidate( else { return Ok(None); }; - let Some((outer_key, width_t)) = projected_collision_role_price( + let Some((outer_key, width_t)) = dimensions.collision_role_price( policy, akita_types::SisMatrixRole::Outer, - d_a, - dimensions.d_b(), width_t, log_basis, ) else { @@ -448,19 +457,20 @@ fn root_final_group_level_params_candidate( else { return Ok(None); }; - let d_width = main_d_width - .checked_add(precommitted_d_width) - .ok_or_else(|| AkitaError::InvalidSetup("root batch D width overflow".to_string()))?; - let Some((open_key, d_width)) = projected_collision_role_price( + let Some((open_key, main_d_width)) = dimensions.collision_role_price( policy, akita_types::SisMatrixRole::Open, - d_a, - dimensions.d_d(), - d_width, + main_d_width, log_basis, ) else { return Ok(None); }; + // Frozen precommit segments are already projected to the root's shared D + // dimension by `precommitted_groups_for_open_basis`; only the main native + // width passes through the A-to-D projection above. + let d_width = main_d_width + .checked_add(precommitted_d_width) + .ok_or_else(|| AkitaError::InvalidSetup("root batch D width overflow".to_string()))?; let Ok(open_commit_matrix) = OpenCommitMatrixParams::try_new_with_min_rank(open_key, d_width) else { return Ok(None); @@ -492,51 +502,27 @@ fn root_final_group_level_params_candidate( Ok(Some(params)) } -fn validate_mixed_dimension_schedule_request( +fn validate_adaptive_dimension_schedule_request( key: &AkitaScheduleLookupKey, policy: &PlannerPolicy, - dimensions: &RingDimensionSearchDomain, ) -> Result<(), AkitaError> { if !key.precommitteds.is_empty() { return Err(AkitaError::UnsupportedSchedule( "mixed-D search is supported only for single-group schedules".to_string(), )); } - if policy.selection_policy - != crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload - { - return Err(AkitaError::InvalidSetup( - "mixed-D search requires MinSetupMatrixFieldElementsThenProofPayload".into(), - )); - } if policy.recursive_setup_planning { return Err(AkitaError::InvalidSetup( - "mixed-D search does not yet support recursive setup planning".into(), + "scalar mixed-D search does not support recursive setup planning; use a grouped request with precommitted inputs".into(), )); } - if policy.witness_chunk.uses_multi_chunk() { + if policy.selection_policy + != crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload + { return Err(AkitaError::InvalidSetup( - "mixed-D search does not yet support direct multi-chunk planning".into(), + "adaptive search requires MinSetupMatrixFieldElementsThenProofPayload".into(), )); } - let suffix_dimensions = CommitmentRingDims::uniform(MIXED_SEARCH_SUFFIX_RING_DIMENSION); - if !dimensions.candidates().contains(&suffix_dimensions) { - return Err(AkitaError::InvalidSetup(format!( - "mixed-D search requires the D{MIXED_SEARCH_SUFFIX_RING_DIMENSION} uniform \ - candidate used from fold level {MIXED_SEARCH_FOLD_LEVELS} onward" - ))); - } - if dimensions.candidates().iter().any(|dims| { - dims.d_a() < MIXED_SEARCH_SUFFIX_RING_DIMENSION - || dims.d_b() < MIXED_SEARCH_SUFFIX_RING_DIMENSION - || dims.d_d() < MIXED_SEARCH_SUFFIX_RING_DIMENSION - }) { - return Err(AkitaError::InvalidSetup(format!( - "mixed-D candidates must be component-wise at least \ - D{MIXED_SEARCH_SUFFIX_RING_DIMENSION} so the schedule can return monotonically \ - to uniform D{MIXED_SEARCH_SUFFIX_RING_DIMENSION}" - ))); - } Ok(()) } @@ -548,27 +534,42 @@ pub fn find_schedule( policy: &PlannerPolicy, ring_challenge_config: impl Fn(usize) -> Result, ) -> Result { - validate_policy(policy)?; + akita_schedules::planner_support::validate_policy(policy)?; key.validate(policy.decomposition.field_bits())?; - let dimensions = - RingDimensionSearchDomain::new(policy.ring_dimension_candidates.iter().copied())?; - dimensions.validate_for_policy(policy)?; - if !dimensions.is_uniform_policy_domain(policy) { - validate_mixed_dimension_schedule_request(key, policy, &dimensions)?; - return mixed_search::find_schedule( - key.final_group, - policy, - final_honest_fold_policy, - &dimensions, - ring_challenge_config, - ); - } - if policy.selection_policy - == crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload - { - return Err(AkitaError::InvalidSetup( - "setup-field mixed selection requires an explicit mixed dimension domain".to_string(), - )); + if matches!( + policy.ring_dimension_schedule_mode, + crate::RingDimensionScheduleMode::AdaptiveDimension { .. } + ) { + if key.precommitteds.is_empty() { + validate_adaptive_dimension_schedule_request(key, policy)?; + } + + if !key.precommitteds.is_empty() && !policy.recursive_setup_planning { + // Direct grouped roots preserve every frozen A/B profile and use + // the established uniform suffix domain. Recursive grouped roots + // continue below into the setup-aware adaptive suffix frontier. + let crate::RingDimensionScheduleMode::AdaptiveDimension { + uniform_suffix_dimension, + .. + } = policy.ring_dimension_schedule_mode + else { + unreachable!("adaptive grouped fallback is entered only for adaptive policies"); + }; + let mut grouped_policy = *policy; + grouped_policy.uniform_ring_dimension = uniform_suffix_dimension; + grouped_policy.ring_dimension_schedule_mode = + crate::RingDimensionScheduleMode::UniformDimension { + ring_dimension: uniform_suffix_dimension, + }; + grouped_policy.selection_policy = crate::SelectionPolicyId::MinEstimatedProofPayload; + return find_schedule( + key, + final_honest_fold_policy, + precommitted_honest_fold_policies, + &grouped_policy, + ring_challenge_config, + ); + } } let ring_challenge_config: RingChallengeConfigFn<'_> = &ring_challenge_config; let scalar_policy; @@ -610,6 +611,20 @@ pub fn find_schedule( level_zero_is_root: true, }; let mut memo = ScheduleMemo::new(); + let dimension_ceiling = match active_policy.ring_dimension_schedule_mode { + crate::RingDimensionScheduleMode::UniformDimension { ring_dimension } => { + CommitmentRingDims::uniform(ring_dimension) + } + crate::RingDimensionScheduleMode::AdaptiveDimension { + potential_a_dimensions, + .. + } => CommitmentRingDims::uniform( + potential_a_dimensions + .last() + .copied() + .ok_or_else(|| AkitaError::InvalidSetup("adaptive A domain is empty".into()))?, + ), + }; let suffix = derive_optimal_suffix_schedule( &suffix_ctx, &mut memo, @@ -618,6 +633,7 @@ pub fn find_schedule( current_witness_len: root_input_witness_len, current_lb: 0, incoming_setup_prefix: None, + dimension_ceiling, payload_phase: akita_types::CommitmentPayloadPhase::CompressedPrefix, }, 0, @@ -627,9 +643,7 @@ pub fn find_schedule( select_complete_candidate(active_policy, suffix.best_by_payload_per_lb.values())? } crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload => { - return Err(AkitaError::UnsupportedSchedule( - "mixed ring-dimension selection is not supported for multi-group roots".to_string(), - )); + select_complete_candidate(active_policy, &suffix.mixed_frontier)? } crate::SelectionPolicyId::MinFirstDirectSetupThenPayload => select_complete_candidate( active_policy, @@ -638,6 +652,18 @@ pub fn find_schedule( }; let Some(best) = best.cloned() else { + if key.precommitteds.is_empty() + && matches!( + active_policy.ring_dimension_schedule_mode, + crate::RingDimensionScheduleMode::AdaptiveDimension { .. } + ) + { + return Err(AkitaError::UnsupportedSchedule(format!( + "no mixed-D schedule with at least two folds for num_vars={}, num_polynomials={}", + key.final_group.num_vars(), + key.final_group.num_polynomials() + ))); + } return Err(AkitaError::UnsupportedSchedule(format!( "no multi-group schedule with at least two folds for num_vars={}", key.final_group.num_vars() diff --git a/crates/akita-planner/src/schedule_params.rs b/crates/akita-planner/src/schedule_params.rs index 53e61ebba..45cc6e327 100644 --- a/crates/akita-planner/src/schedule_params.rs +++ b/crates/akita-planner/src/schedule_params.rs @@ -1,6 +1,4 @@ -//! FoldSchedule planner that finds the global minimum proof size. Recursive -//! grouped scheduling additionally minimizes the first direct setup footprint -//! before proof size. +//! FoldSchedule planner that applies each catalog-bound selection objective. //! //! Public entry: [`crate::find_schedule`]. The search is `Cfg`-free: every //! per-preset input is carried by the plain-value [`PlannerPolicy`] plus @@ -18,26 +16,28 @@ use akita_types::sis::{ InnerCommitMatrixParams, OpenCommitMatrixParams, OuterCommitMatrixParams, }; use akita_types::{ - dyadic_block_ranges, level_proof_bytes, padded_setup_prefix_len, - try_extension_opening_reduction_level_bytes, AkitaScheduleLookupKey, CommitmentRingDims, - CommittedGroupParams, CommittedGroupProfile, DecompositionParams, FoldSchedule, - FoldScheduleEstimate, PlannedFoldSchedule, PolynomialGroupLayout, PrecommittedLevelParams, - RecursiveFoldParams, RecursiveFoldStep, RootFinalGroupParams, RootFoldParams, RootFoldStep, - RootPrecommittedGroupParams, TerminalFoldParams, TerminalFoldStep, TerminalResponseShape, - WitnessLayout, WitnessPartition, + dyadic_block_ranges, padded_setup_prefix_len, AkitaScheduleLookupKey, CommitmentRingDims, + CommittedGroupParams, CommittedGroupProfile, DecompositionParams, PolynomialGroupLayout, + PrecommittedLevelParams, +}; +#[cfg(test)] +use akita_types::{ + level_proof_bytes, try_extension_opening_reduction_level_bytes, PlannedFoldSchedule, }; use crate::PlannerPolicy; mod candidate; -pub(crate) mod mixed_search; mod objective; mod setup_score; mod suffix_dp; #[cfg(test)] #[path = "test/unpruned_search.rs"] mod unpruned_search; - +pub(crate) use akita_schedules::planner_support::{ + materialize_candidate_schedule, stage3_payload_bytes_for_successor, CandidateFoldStep, + CandidateTerminalResponse, +}; pub use akita_types::suffix_opening_layout; pub(crate) use candidate::{ derive_candidate_level_params, derive_candidate_level_params_all_splits, @@ -48,43 +48,94 @@ pub(crate) use setup_score::{ }; pub(crate) use suffix_dp::{derive_optimal_suffix_schedule, ScheduleMemo, SuffixCtx, SuffixState}; -pub(crate) const MIXED_SEARCH_FOLD_LEVELS: usize = 2; -pub(crate) const MIXED_SEARCH_SUFFIX_RING_DIMENSION: usize = 64; - -#[derive(Clone, Debug)] -pub(crate) struct CandidateFoldStep { - pub(crate) params: CommittedGroupParams, - pub(crate) input_witness_len: usize, - pub(crate) output_witness_len: usize, - pub(crate) estimated_direct_payload_bytes: usize, - pub(crate) estimated_stage3_payload_bytes: usize, +fn dimension_candidates( + policy: &PlannerPolicy, + level: usize, + ceiling: CommitmentRingDims, +) -> Result>, AkitaError> { + use akita_schedules::planner_support::RingDimensionCandidate; + + ceiling.validate_role_projection()?; + let candidates = match policy.ring_dimension_schedule_mode { + crate::RingDimensionScheduleMode::UniformDimension { ring_dimension } => { + vec![RingDimensionCandidate::Fixed(CommitmentRingDims::uniform( + ring_dimension, + ))] + } + crate::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + } => { + if level >= num_search_levels { + vec![RingDimensionCandidate::Fixed(CommitmentRingDims::uniform( + uniform_suffix_dimension, + ))] + } else if policy.selection_policy + == crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload + { + potential_a_dimensions + .iter() + .copied() + .filter(|&inner| inner <= ceiling.d_a()) + .map(|inner| RingDimensionCandidate::Adaptive { + inner, + outer_dimensions: potential_b_dimensions, + opening_dimensions: potential_d_dimensions, + ceiling, + }) + .collect() + } else { + let mut candidates = Vec::new(); + for &inner in potential_a_dimensions { + if inner > ceiling.d_a() { + continue; + } + for &outer in potential_b_dimensions { + if outer > ceiling.d_b() || !inner.is_multiple_of(outer) { + continue; + } + for &opening in potential_d_dimensions { + if opening > ceiling.d_d() || !inner.is_multiple_of(opening) { + continue; + } + candidates.push(RingDimensionCandidate::Fixed(CommitmentRingDims { + inner, + outer, + opening, + })); + } + } + } + candidates + } + } + }; + Ok(candidates) } -#[derive(Clone, Debug)] -pub(crate) struct CandidateTerminalResponse { - pub(crate) params: akita_types::TerminalCommittedGroupParams, - pub(crate) sparse_challenge_config: akita_challenges::SparseChallengeConfig, - pub(crate) input_witness_len: usize, - pub(crate) estimated_direct_payload_bytes: usize, - pub(crate) response_shape: TerminalResponseShape, - pub(crate) estimated_payload_bytes: usize, -} +#[cfg(test)] +pub(crate) const ADAPTIVE_SUFFIX_RING_DIMENSION: usize = 64; /// Explicit A/B/D dimensions admitted by mixed-D planner search. /// /// The planner policy's uniform ring dimension defines only the implicit /// singleton domain used by [`crate::find_schedule`]. Mixed-dimension search supplies /// this explicit set of schedule-owned A/B/D tuples. +#[cfg(test)] #[derive(Clone, Debug, PartialEq, Eq)] -pub struct RingDimensionSearchDomain { +pub(crate) struct RingDimensionSearchDomain { candidates: Vec, } +#[cfg(test)] impl RingDimensionSearchDomain { /// Construct and canonicalize a non-empty dimension domain. /// /// Every tuple must satisfy the schedule-local A-carrier invariant. - pub fn new( + pub(crate) fn new( candidates: impl IntoIterator, ) -> Result { let mut candidates = candidates.into_iter().collect::>(); @@ -102,31 +153,29 @@ impl RingDimensionSearchDomain { } /// Construct the explicit singleton domain used by a uniform policy. - pub fn uniform(ring_dimension: usize) -> Result { + pub(crate) fn uniform(ring_dimension: usize) -> Result { Self::new([CommitmentRingDims::uniform(ring_dimension)]) } /// Canonically ordered admitted A/B/D tuples. - pub fn candidates(&self) -> &[CommitmentRingDims] { + pub(crate) fn candidates(&self) -> &[CommitmentRingDims] { &self.candidates } + #[cfg(test)] pub(crate) fn validate_for_policy(&self, policy: &PlannerPolicy) -> Result<(), AkitaError> { - if self.candidates.as_slice() != policy.ring_dimension_candidates { - if policy.ring_dimension_candidates.len() == 1 { - return Ok(()); - } - return Err(AkitaError::InvalidSetup( - "ring-dimension search domain disagrees with the catalog-bound policy domain" - .to_string(), - )); - } - Ok(()) + akita_schedules::planner_support::validate_policy(policy) } +} - pub(crate) fn is_uniform_policy_domain(&self, policy: &PlannerPolicy) -> bool { - self.candidates.as_slice() == [CommitmentRingDims::uniform(policy.uniform_ring_dimension)] - } +#[cfg(test)] +fn componentwise_dimensions_at_most( + dimensions: CommitmentRingDims, + ceiling: CommitmentRingDims, +) -> bool { + dimensions.d_a() <= ceiling.d_a() + && dimensions.d_b() <= ceiling.d_b() + && dimensions.d_d() <= ceiling.d_d() } #[derive(Clone, Debug)] @@ -160,131 +209,6 @@ impl ScheduleCandidate { } } -/// Exact Stage-3 payload induced when `successor` consumes the setup prefix -/// produced by the current fold. Absence of a successor prefix is direct mode. -pub(crate) fn stage3_payload_bytes_for_successor( - policy: &PlannerPolicy, - successor: Option<&CommittedGroupParams>, -) -> Result { - let Some(prefix) = successor.and_then(|params| params.setup_prefix.as_ref()) else { - return Ok(usize::default()); - }; - let n_prefix = prefix.n_prefix()?; - if prefix.d_setup() == 0 || !n_prefix.is_multiple_of(prefix.d_setup()) { - return Err(AkitaError::InvalidSetup( - "setup-prefix field length does not align with its ring dimension".to_string(), - )); - } - let challenge_field_bits = policy.challenge_field_bits()?; - Ok(akita_types::proof_size::stage3_setup_product_bytes( - challenge_field_bits, - prefix.d_setup(), - n_prefix / prefix.d_setup(), - )) -} - -pub(crate) fn materialize_candidate_schedule( - cached_total: usize, - cached_num_setup_field_elements: usize, - first_direct_setup_field_len: Option, - mut folds: Vec, - terminal_response: CandidateTerminalResponse, -) -> Result { - if folds.is_empty() { - return Err(AkitaError::UnsupportedSchedule( - "a fold schedule requires root and terminal folds".to_string(), - )); - } - let root = folds.remove(0); - let mut estimate = FoldScheduleEstimate { - estimated_root_direct_payload_bytes: root.estimated_direct_payload_bytes, - estimated_root_stage3_payload_bytes: root.estimated_stage3_payload_bytes, - estimated_recursive_direct_payload_bytes: folds - .iter() - .map(|fold| fold.estimated_direct_payload_bytes) - .collect(), - estimated_recursive_stage3_payload_bytes: folds - .iter() - .map(|fold| fold.estimated_stage3_payload_bytes) - .collect(), - estimated_terminal_direct_payload_bytes: terminal_response - .estimated_direct_payload_bytes - .checked_add(terminal_response.estimated_payload_bytes) - .ok_or_else(|| AkitaError::InvalidSetup("terminal estimate overflow".to_string()))?, - estimated_terminal_response_payload_bytes: terminal_response.estimated_payload_bytes, - estimated_num_setup_field_elements: cached_num_setup_field_elements, - first_direct_setup_field_len, - selected_offload_edges: 0, - }; - let recomputed = estimate.estimated_proof_payload_bytes()?; - if recomputed != cached_total { - return Err(AkitaError::InvalidSetup(format!( - "cached planner cost {cached_total} disagrees with materialized estimate {recomputed}" - ))); - } - let schedule = FoldSchedule { - root: RootFoldStep { - params: RootFoldParams { - final_group: RootFinalGroupParams { - commitment: root.params.clone(), - }, - precommitted_groups: root - .params - .precommitted_groups - .iter() - .cloned() - .map(|commitment| RootPrecommittedGroupParams { - descriptor: commitment.layout, - commitment, - }) - .collect(), - open_commit_matrix: root.params.open_commit_matrix, - sparse_challenge_config: root.params.fold_challenge_config, - witness_partition: witness_partition(root.params.witness_chunk.num_chunks), - }, - input_witness_len: root.input_witness_len, - output_witness_len: root.output_witness_len, - }, - recursive_folds: folds - .into_iter() - .map(|fold| RecursiveFoldStep { - params: RecursiveFoldParams { - open_commit_matrix: fold.params.open_commit_matrix, - sparse_challenge_config: fold.params.fold_challenge_config, - incoming_setup_prefix: fold.params.setup_prefix.clone(), - witness_partition: witness_partition(fold.params.witness_chunk.num_chunks), - witness: fold.params, - }, - input_witness_len: fold.input_witness_len, - output_witness_len: fold.output_witness_len, - }) - .collect(), - terminal: TerminalFoldStep { - params: TerminalFoldParams { - sparse_challenge_config: terminal_response.sparse_challenge_config, - witness: terminal_response.params, - response_shape: terminal_response.response_shape, - }, - input_witness_len: terminal_response.input_witness_len, - }, - }; - schedule.validate_structure()?; - let recomputed_setup_field_elements = - akita_types::setup_matrix_field_elements_for_schedule(&schedule)?; - if recomputed_setup_field_elements != cached_num_setup_field_elements { - return Err(AkitaError::InvalidSetup(format!( - "cached setup field count {cached_num_setup_field_elements} disagrees with materialized \ - count {recomputed_setup_field_elements}" - ))); - } - estimate.selected_offload_edges = schedule - .recursive_folds - .iter() - .filter(|fold| fold.params.incoming_setup_prefix.is_some()) - .count(); - Ok(PlannedFoldSchedule { schedule, estimate }) -} - pub(crate) fn candidate_schedule_descriptor_bytes( choice: &ScheduleCandidate, ) -> Result, AkitaError> { @@ -299,80 +223,6 @@ pub(crate) fn candidate_schedule_descriptor_bytes( .canonical_descriptor_bytes()) } -fn witness_partition(num_chunks: usize) -> WitnessPartition { - if num_chunks == 1 { - WitnessPartition::Single - } else { - WitnessPartition::Distributed { num_chunks } - } -} - -/// Validate the complete planner policy at a verifier-reachable entry point. -/// -/// Layout-only rules live on [`akita_types::ChunkedWitnessCfg::validate`]; the recursion-depth -/// bound (which needs the planner-private [`MAX_RECURSION_DEPTH`]) is enforced -/// here so `akita-types` stays free of planner internals. -/// -/// # Errors -/// -/// Returns [`AkitaError::InvalidSetup`] for an invalid [`akita_types::ChunkedWitnessCfg`], or -/// `num_activated_levels` beyond the planner recursion cap. Verifier-reachable: never panics. -pub(crate) fn validate_policy(policy: &PlannerPolicy) -> Result<(), AkitaError> { - policy.challenge_field_bits()?; - let expected_selection_policy = if policy.recursive_setup_planning { - crate::SelectionPolicyId::MinFirstDirectSetupThenPayload - } else if policy.ring_dimension_candidates.len() > 1 { - crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload - } else { - match policy.selection_policy { - crate::SelectionPolicyId::MinEstimatedProofPayload - | crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload => { - policy.selection_policy - } - crate::SelectionPolicyId::MinFirstDirectSetupThenPayload => { - crate::SelectionPolicyId::MinEstimatedProofPayload - } - } - }; - if policy.selection_policy != expected_selection_policy { - return Err(AkitaError::InvalidSetup( - "planner selection policy disagrees with recursive setup capability".to_string(), - )); - } - if policy.setup_field_budget == Some(0) { - return Err(AkitaError::InvalidSetup( - "explicit setup field budget must be positive".to_string(), - )); - } - for (label, dimension) in [ - ("uniform", policy.uniform_ring_dimension), - ( - "setup-prefix inner", - policy.setup_prefix_inner_ring_dimension, - ), - ] { - if !dimension.is_power_of_two() { - return Err(AkitaError::InvalidSetup(format!( - "planner {label} ring dimension must be a nonzero power of two" - ))); - } - } - if policy.min_offloaded_witness_contraction == 0 { - return Err(AkitaError::InvalidSetup( - "minimum offloaded witness contraction must be positive".to_string(), - )); - } - let mc = policy.witness_chunk; - mc.validate()?; - if mc.num_activated_levels > MAX_RECURSION_DEPTH { - return Err(AkitaError::InvalidSetup(format!( - "num_activated_levels={} exceeds the planner recursion cap {MAX_RECURSION_DEPTH}", - mc.num_activated_levels - ))); - } - Ok(()) -} - /// Stage-1 sparse-challenge closure shared by the planner entry points. pub(crate) type RingChallengeConfigFn<'a> = &'a dyn Fn(usize) -> Result; @@ -411,10 +261,9 @@ pub(crate) fn layout_candidate_score( /// Offline canonical standalone precommit descriptor for one group. /// -/// Runtime config code consumes generated [`CommittedGroupProfile`] rows -/// instead of running this search. The returned profile freezes only group-local -/// A/B commitment geometry; grouped-root schedule expansion later derives D/open -/// metadata when the final group is known. +/// Root precommits are selected independently of any future final-group +/// schedule. Adaptive policies use their uniform suffix dimension for both A +/// and B; final groups retain the full per-level adaptive search. pub fn derive_standalone_precommit_profile( key: PolynomialGroupLayout, policy: &PlannerPolicy, @@ -422,49 +271,52 @@ pub fn derive_standalone_precommit_profile( ring_challenge_config: impl Fn(usize) -> Result, ) -> Result { key.validate()?; + let schedule_key = AkitaScheduleLookupKey::single(key); let mut direct_policy = policy.direct_only(); + let precommit_dimension = match policy.ring_dimension_schedule_mode { + crate::RingDimensionScheduleMode::UniformDimension { ring_dimension } => ring_dimension, + crate::RingDimensionScheduleMode::AdaptiveDimension { + uniform_suffix_dimension, + .. + } => uniform_suffix_dimension, + }; + direct_policy.uniform_ring_dimension = precommit_dimension; + direct_policy.ring_dimension_schedule_mode = + crate::RingDimensionScheduleMode::UniformDimension { + ring_dimension: precommit_dimension, + }; + direct_policy.selection_policy = + crate::SelectionPolicyId::for_policy(false, direct_policy.ring_dimension_schedule_mode); direct_policy.basis_range = (direct_policy.basis_range.0, direct_policy.basis_range.0); - validate_policy(&direct_policy)?; - + akita_schedules::planner_support::validate_policy(&direct_policy)?; let witness_len = 1usize .checked_shl(key.num_vars() as u32) .ok_or_else(|| AkitaError::InvalidSetup("precommit witness too large".into()))?; let (min_log_basis, max_log_basis) = direct_policy.log_basis_search_range_at_level(0); let mut best: Option<(usize, CommittedGroupParams)> = None; - let schedule_key = AkitaScheduleLookupKey::single(key); - for candidate_log_basis in min_log_basis..=max_log_basis { - for dimensions in direct_policy.ring_dimension_candidates.iter().copied() { - let Ok(ring_challenge_cfg) = ring_challenge_config(dimensions.d_a()) else { - continue; - }; - let alpha = (dimensions.d_a() as u32).trailing_zeros() as usize; - let reduced_vars = key.num_vars().saturating_sub(alpha); - if reduced_vars == 0 { - continue; - } - for (candidate_params, next_witness_len) in - crate::planner::root_level_candidates_for_basis( - &schedule_key, - honest_fold_policy, - &[], - &direct_policy, - dimensions, - &ring_challenge_cfg, - &ring_challenge_config, - witness_len, - candidate_log_basis, - false, - )? - { - match &best { - Some((best_len, _)) if *best_len <= next_witness_len => {} - _ => best = Some((next_witness_len, candidate_params)), - } + let dimensions = akita_schedules::planner_support::RingDimensionCandidate::Fixed( + CommitmentRingDims::uniform(precommit_dimension), + ); + let ring_challenge_cfg = ring_challenge_config(precommit_dimension)?; + for (candidate_params, next_witness_len) in crate::planner::root_level_candidates_for_basis( + &schedule_key, + honest_fold_policy, + &[], + &direct_policy, + dimensions, + &ring_challenge_cfg, + &ring_challenge_config, + witness_len, + candidate_log_basis, + false, + )? { + match &best { + Some((best_len, _)) if *best_len <= next_witness_len => {} + _ => best = Some((next_witness_len, candidate_params)), } } } - best.map(|(_, params)| CommittedGroupProfile::from_params(key, ¶ms)) .ok_or_else(|| { AkitaError::InvalidSetup(format!( @@ -473,20 +325,6 @@ pub fn derive_standalone_precommit_profile( }) } -// Suffix-DP depth cap. Schedules in our working parameter range never need -// more than this many recursive fold levels; deeper search only blows up -// memo state without changing emitted tables. -pub(crate) const MAX_RECURSION_DEPTH: usize = 12; - -fn componentwise_dimensions_at_most( - dimensions: CommitmentRingDims, - ceiling: CommitmentRingDims, -) -> bool { - dimensions.d_a() <= ceiling.d_a() - && dimensions.d_b() <= ceiling.d_b() - && dimensions.d_d() <= ceiling.d_d() -} - #[cfg(test)] #[path = "test/schedule_params.rs"] mod tests; diff --git a/crates/akita-planner/src/schedule_params/candidate.rs b/crates/akita-planner/src/schedule_params/candidate.rs index b1d49dba8..830d63743 100644 --- a/crates/akita-planner/src/schedule_params/candidate.rs +++ b/crates/akita-planner/src/schedule_params/candidate.rs @@ -1,6 +1,9 @@ use super::*; -use akita_schedules::planner_support::{projected_collision_role_price, sis_key_at_dimension}; +pub(crate) use akita_schedules::planner_support::planned_next_witness_len; +use akita_schedules::planner_support::{ + grouped_segment_rings, sis_key_at_dimension, RingDimensionCandidate, +}; mod recursive; mod setup_prefix; @@ -9,7 +12,6 @@ pub(crate) use recursive::{ derive_candidate_level_params, derive_candidate_level_params_all_splits, }; pub(super) use setup_prefix::derive_setup_prefix_group; -pub(crate) use setup_prefix::planned_next_witness_len; #[cfg(test)] #[path = "../test/schedule_params_candidate.rs"] diff --git a/crates/akita-planner/src/schedule_params/candidate/recursive.rs b/crates/akita-planner/src/schedule_params/candidate/recursive.rs index 110f8af59..b78cb9752 100644 --- a/crates/akita-planner/src/schedule_params/candidate/recursive.rs +++ b/crates/akita-planner/src/schedule_params/candidate/recursive.rs @@ -8,7 +8,7 @@ use super::*; pub(crate) fn recursive_fold_level_params_candidate( policy: &PlannerPolicy, ring_challenge_cfg: &akita_challenges::SparseChallengeConfig, - dimensions: CommitmentRingDims, + dimensions: RingDimensionCandidate<'_>, num_ring_elems: usize, reduced_vars: usize, log_basis: u32, @@ -38,18 +38,19 @@ pub(crate) fn recursive_fold_level_params_candidate( let Some(width_s) = decomposed_s_block_ring_count(num_positions_per_block, delta_commit) else { return Ok(None); }; + let d_a = dimensions.inner(); let Some(num_fold_coeffs) = width_s - .checked_mul(dimensions.d_a()) + .checked_mul(d_a) .and_then(|count| count.checked_mul(num_chunks)) else { return Ok(None); }; let fold_policy = BalancedSignedDigitFoldPolicy::preserving_existing_behavior( policy.decomposition.field_bits(), - FoldWitnessNorms::bounded(decomp.log_basis, dimensions.d_a()), + FoldWitnessNorms::bounded(decomp.log_basis, d_a), ); let Ok(num_digits_fold) = fold_policy.num_digits_fold(HonestFoldSizingQuery { - ring_dimension: dimensions.d_a(), + ring_dimension: d_a, num_claims: 1, num_live_blocks, num_chunks, @@ -63,7 +64,7 @@ pub(crate) fn recursive_fold_level_params_candidate( policy.sis_security_policy, policy.sis_table_digest, policy.sis_modulus_profile, - dimensions.d_a(), + d_a, decomp.log_basis, ring_challenge_cfg, num_digits_fold, @@ -72,12 +73,7 @@ pub(crate) fn recursive_fold_level_params_candidate( return Ok(None); }; let Ok(inner_commit_matrix) = InnerCommitMatrixParams::try_new_with_min_rank( - sis_key_at_dimension( - policy, - akita_types::SisMatrixRole::Inner, - dimensions.d_a(), - norm_s, - ), + sis_key_at_dimension(policy, akita_types::SisMatrixRole::Inner, d_a, norm_s), width_s, ) else { return Ok(None); @@ -90,11 +86,9 @@ pub(crate) fn recursive_fold_level_params_candidate( ) else { return Ok(None); }; - let Some((outer_key, width_t)) = projected_collision_role_price( + let Some((outer_key, width_t)) = dimensions.collision_role_price( policy, akita_types::SisMatrixRole::Outer, - dimensions.d_a(), - dimensions.d_b(), native_width_t, log_basis, ) else { @@ -108,11 +102,9 @@ pub(crate) fn recursive_fold_level_params_candidate( let Some(native_width_w) = decomposed_w_ring_count(delta_open, num_live_blocks, 1) else { return Ok(None); }; - let Some((open_key, width_w)) = projected_collision_role_price( + let Some((open_key, width_w)) = dimensions.collision_role_price( policy, akita_types::SisMatrixRole::Open, - dimensions.d_a(), - dimensions.d_d(), native_width_w, log_basis, ) else { @@ -262,14 +254,15 @@ struct RecursiveLevelSearch { fn prepare_recursive_level_search( policy: &PlannerPolicy, ring_challenge_cfg: &akita_challenges::SparseChallengeConfig, - dimensions: CommitmentRingDims, + dimensions: RingDimensionCandidate<'_>, current_witness_len: usize, log_basis: u32, fold_level: usize, incoming_setup_prefix: Option, ) -> Result, AkitaError> { let num_chunks = policy.chunks_at_level(fold_level); - dimensions.validate_role_projection()?; + dimensions.validate()?; + let d_a = dimensions.inner(); if current_witness_len == 0 { return Ok(None); } @@ -277,7 +270,7 @@ fn prepare_recursive_level_search( // end on the next A-ring boundary; commitment alignment pads only the // transient ring view. Plan from the live coefficient count, rounding up // solely to determine the next fold's block geometry. - let num_ring_elems = current_witness_len.div_ceil(dimensions.d_a()); + let num_ring_elems = current_witness_len.div_ceil(d_a); let reduced_vars = num_ring_elems .checked_next_power_of_two() .ok_or_else(|| AkitaError::InvalidSetup("recursive witness capacity overflow".to_string()))? @@ -301,7 +294,11 @@ fn prepare_recursive_level_search( log_basis, n_prefix, num_chunks, - dimensions.d_b(), + d_a, + match dimensions { + RingDimensionCandidate::Fixed(value) => value.d_b(), + RingDimensionCandidate::Adaptive { .. } => d_a, + }, )? else { return Ok(None); @@ -323,7 +320,7 @@ fn recursive_level_candidate_for_split( policy: &PlannerPolicy, payload_mode: akita_types::CommitmentPayloadMode, ring_challenge_cfg: &akita_challenges::SparseChallengeConfig, - dimensions: CommitmentRingDims, + dimensions: RingDimensionCandidate<'_>, search: &RecursiveLevelSearch, log_basis: u32, fold_level: usize, @@ -382,7 +379,7 @@ pub(crate) fn derive_candidate_level_params( policy: &PlannerPolicy, payload_mode: akita_types::CommitmentPayloadMode, ring_challenge_cfg: &akita_challenges::SparseChallengeConfig, - dimensions: CommitmentRingDims, + dimensions: RingDimensionCandidate<'_>, current_witness_len: usize, log_basis: u32, fold_level: usize, @@ -433,7 +430,7 @@ pub(crate) fn derive_candidate_level_params( if let Some((best_score, _, _, _)) = &best { if let Some(lower_bound) = recursive_split_lower_bound(RecursiveSplitLowerBoundInput { num_ring_elems: search.num_ring_elems, - ring_dimension: dimensions.d_a(), + ring_dimension: dimensions.inner(), reduced_vars: search.reduced_vars, r, delta_commit, @@ -483,7 +480,7 @@ pub(crate) fn derive_candidate_level_params_all_splits( policy: &PlannerPolicy, payload_mode: akita_types::CommitmentPayloadMode, ring_challenge_cfg: &akita_challenges::SparseChallengeConfig, - dimensions: CommitmentRingDims, + dimensions: RingDimensionCandidate<'_>, current_witness_len: usize, log_basis: u32, fold_level: usize, diff --git a/crates/akita-planner/src/schedule_params/candidate/setup_prefix.rs b/crates/akita-planner/src/schedule_params/candidate/setup_prefix.rs index f3791f018..e8e374b1c 100644 --- a/crates/akita-planner/src/schedule_params/candidate/setup_prefix.rs +++ b/crates/akita-planner/src/schedule_params/candidate/setup_prefix.rs @@ -12,65 +12,6 @@ fn checked_power_of_two_vars(field_len: usize, context: &'static str) -> Result< Ok(padded.trailing_zeros() as usize) } -#[allow(clippy::too_many_arguments)] -fn grouped_segment_rings( - num_polys: usize, - num_live_blocks: usize, - num_chunks: usize, - num_positions_per_block: usize, - n_a: usize, - num_digits_inner: usize, - num_digits_outer: usize, - num_digits_open: usize, - num_digits_fold: usize, -) -> Result { - let e_hat = num_polys - .checked_mul(num_live_blocks) - .and_then(|n| n.checked_mul(num_digits_open)) - .ok_or_else(|| AkitaError::InvalidSetup("group e-hat witness overflow".to_string()))?; - let t_hat = num_polys - .checked_mul(num_live_blocks) - .and_then(|n| n.checked_mul(n_a)) - .and_then(|n| n.checked_mul(num_digits_outer)) - .ok_or_else(|| AkitaError::InvalidSetup("group t-hat witness overflow".to_string()))?; - let z_hat = num_positions_per_block - .checked_mul(num_digits_inner) - .and_then(|n| n.checked_mul(num_digits_fold)) - .and_then(|n| n.checked_mul(num_chunks)) - .ok_or_else(|| AkitaError::InvalidSetup("group z-hat witness overflow".to_string()))?; - - e_hat - .checked_add(t_hat) - .and_then(|n| n.checked_add(z_hat)) - .ok_or_else(|| AkitaError::InvalidSetup("group witness overflow".to_string())) -} - -pub(crate) fn planned_next_witness_len( - field_bits: u32, - params: &CommittedGroupParams, - final_num_polys: usize, - num_chunks: usize, -) -> Result, AkitaError> { - if !params.precommitted_groups.is_empty() { - return Err(AkitaError::InvalidSetup( - "multi-group root witness sizing must use CommittedGroupParams::output_witness_len" - .to_string(), - )); - } - if !params.compression_sources_supported()? { - return Ok(None); - } - let opening_batch = - params.opening_layout_for_final_group(PolynomialGroupLayout::new(0, final_num_polys))?; - let layout = WitnessLayout::new( - params, - &opening_batch, - num_chunks, - akita_types::sis::compute_num_digits_field_width(field_bits, params.log_basis_open), - )?; - Ok(Some(layout.live_coeff_len())) -} - #[allow(clippy::too_many_arguments)] pub(in crate::schedule_params) fn derive_setup_prefix_group( policy: &PlannerPolicy, @@ -79,13 +20,12 @@ pub(in crate::schedule_params) fn derive_setup_prefix_group( log_basis_open: u32, n_prefix: usize, num_chunks: usize, + inner_ring_dimension: usize, outer_ring_dimension: usize, ) -> Result, AkitaError> { if outer_ring_dimension == 0 || !outer_ring_dimension.is_power_of_two() - || !policy - .setup_prefix_inner_ring_dimension - .is_multiple_of(outer_ring_dimension) + || !inner_ring_dimension.is_multiple_of(outer_ring_dimension) { return Err(AkitaError::InvalidSetup( "setup-prefix B dimension must be a power-of-two divisor of its A dimension" @@ -97,7 +37,7 @@ pub(in crate::schedule_params) fn derive_setup_prefix_group( "setup prefix length must be a nonzero power of two".to_string(), )); } - if !n_prefix.is_multiple_of(policy.setup_prefix_inner_ring_dimension) { + if !n_prefix.is_multiple_of(inner_ring_dimension) { return Err(AkitaError::InvalidSetup( "setup prefix length must be a multiple of the ring dimension".to_string(), )); @@ -107,11 +47,11 @@ pub(in crate::schedule_params) fn derive_setup_prefix_group( "setup-prefix checkpoint requires one consuming inner/outer/open basis".to_string(), )); } - let ring_slots = n_prefix / policy.setup_prefix_inner_ring_dimension; + let ring_slots = n_prefix / inner_ring_dimension; let reduced_vars = checked_power_of_two_vars(ring_slots, "setup prefix ring slots")?; let prefix_num_vars = checked_power_of_two_vars(n_prefix, "setup prefix field length")?; let family = policy.sis_modulus_profile; - let d = policy.setup_prefix_inner_ring_dimension; + let d = inner_ring_dimension; let outer_decomp = DecompositionParams { log_basis: log_basis_outer, ..policy.decomposition @@ -183,7 +123,7 @@ pub(in crate::schedule_params) fn derive_setup_prefix_group( sis_key_at_dimension( policy, akita_types::SisMatrixRole::Inner, - policy.setup_prefix_inner_ring_dimension, + inner_ring_dimension, norm_s, ), width_s, diff --git a/crates/akita-planner/src/schedule_params/mixed_search.rs b/crates/akita-planner/src/schedule_params/mixed_search.rs deleted file mode 100644 index 963b769b1..000000000 --- a/crates/akita-planner/src/schedule_params/mixed_search.rs +++ /dev/null @@ -1,390 +0,0 @@ -use std::collections::HashMap; - -use super::*; - -type MixedMemo = HashMap< - ( - usize, - usize, - u32, - usize, - usize, - usize, - akita_types::CommitmentPayloadPhase, - ), - Vec, ->; - -fn score(candidate: &ScheduleCandidate) -> MixedScore { - MixedScore { - setup_field_elements: candidate.setup_field_elements, - proof_bytes: candidate.total_bytes, - } -} - -fn dominates_score(left: MixedScore, right: MixedScore) -> bool { - left.setup_field_elements <= right.setup_field_elements - // A setup-only improvement is not safe to prune: a parent can mask - // both setup footprints with the same envelope, after which the - // descriptor tie-break must still see both candidates. - && left.proof_bytes < right.proof_bytes -} - -fn dominates(left: &ScheduleCandidate, right: &ScheduleCandidate) -> bool { - dominates_score(score(left), score(right)) -} - -fn insert_frontier(frontier: &mut Vec, candidate: ScheduleCandidate) { - let same_first_step = - |other: &ScheduleCandidate| other.first_fold_params() == candidate.first_fold_params(); - if frontier - .iter() - .any(|other| same_first_step(other) && dominates(other, &candidate)) - { - return; - } - frontier.retain(|other| !same_first_step(other) || !dominates(&candidate, other)); - frontier.push(candidate); -} - -fn insert_supported( - policy: &PlannerPolicy, - frontier: &mut Vec, - candidate: ScheduleCandidate, -) { - if policy.admits_setup_field_elements(candidate.setup_field_elements) { - insert_frontier(frontier, candidate); - } -} - -#[allow(clippy::too_many_arguments)] -fn suffix_frontier( - policy: &PlannerPolicy, - dimensions: &RingDimensionSearchDomain, - ring_challenge_config: &dyn Fn(usize) -> Result, - key: PolynomialGroupLayout, - level: usize, - input_witness_len: usize, - current_log_basis: u32, - dimension_ceiling: CommitmentRingDims, - payload_phase: akita_types::CommitmentPayloadPhase, - memo: &mut MixedMemo, -) -> Result, AkitaError> { - if level > MAX_RECURSION_DEPTH { - return Ok(Vec::new()); - } - let memo_key = ( - level, - input_witness_len, - current_log_basis, - dimension_ceiling.d_a(), - dimension_ceiling.d_b(), - dimension_ceiling.d_d(), - payload_phase, - ); - if let Some(cached) = memo.get(&memo_key) { - return Ok(cached.clone()); - } - - let field_bits = policy.decomposition.field_bits(); - let challenge_field_bits = policy.challenge_field_bits()?; - let (min_log_basis, max_log_basis) = policy.log_basis_search_range_at_level(level); - let mut frontier = Vec::new(); - - for log_basis in min_log_basis.max(current_log_basis)..=max_log_basis { - for candidate_dimensions in dimensions.candidates() { - let suffix_dimensions = CommitmentRingDims::uniform(MIXED_SEARCH_SUFFIX_RING_DIMENSION); - if level >= MIXED_SEARCH_FOLD_LEVELS { - if *candidate_dimensions != suffix_dimensions { - continue; - } - } else if !componentwise_dimensions_at_most(*candidate_dimensions, dimension_ceiling) { - continue; - } - let Some(eor_bytes) = try_extension_opening_reduction_level_bytes( - challenge_field_bits, - policy.claim_ext_degree, - level, - key, - input_witness_len, - candidate_dimensions.d_a(), - )? - else { - continue; - }; - let Ok(ring_challenge) = ring_challenge_config(candidate_dimensions.d_a()) else { - continue; - }; - for &payload_mode in payload_phase.candidate_modes(level, false) { - let candidates = if level < MIXED_SEARCH_FOLD_LEVELS { - derive_candidate_level_params_all_splits( - policy, - payload_mode, - &ring_challenge, - *candidate_dimensions, - input_witness_len, - log_basis, - level, - None, - )? - } else { - derive_candidate_level_params( - policy, - payload_mode, - &ring_challenge, - *candidate_dimensions, - input_witness_len, - log_basis, - level, - None, - )? - .into_iter() - .collect() - }; - - for (params, output_witness_len) in candidates { - if level >= MIXED_SEARCH_FOLD_LEVELS { - if let Some((mut terminal, terminal_bytes)) = - suffix_dp::try_terminal_direct_suffix_cost( - input_witness_len, - ¶ms, - field_bits, - key, - level, - None, - )? - { - let direct_bytes = akita_types::proof_size::FOLD_GRIND_NONCE_BYTES - .checked_add(eor_bytes) - .ok_or_else(|| { - AkitaError::InvalidSetup( - "mixed terminal proof size overflow".into(), - ) - })?; - terminal.estimated_direct_payload_bytes = direct_bytes; - insert_supported( - policy, - &mut frontier, - ScheduleCandidate { - first_direct_setup_field_len: Some( - akita_types::active_setup_field_len( - ¶ms, - &suffix_opening_layout(input_witness_len, None)?, - )?, - ), - total_bytes: direct_bytes - .checked_add(terminal_bytes) - .ok_or_else(|| { - AkitaError::InvalidSetup( - "mixed terminal proof size overflow".into(), - ) - })?, - setup_field_elements: terminal_setup_field_elements( - &terminal.params, - )?, - folds: Vec::new(), - terminal, - }, - ); - } - } - - let child_ceiling = if level + 1 >= MIXED_SEARCH_FOLD_LEVELS { - CommitmentRingDims::uniform(MIXED_SEARCH_SUFFIX_RING_DIMENSION) - } else { - params.role_dims() - }; - for child in suffix_frontier( - policy, - dimensions, - ring_challenge_config, - key, - level + 1, - output_witness_len, - log_basis, - child_ceiling, - payload_phase.after(params.payload_mode), - memo, - )? { - let child_is_terminal = child.folds.is_empty(); - let direct_bytes = level_proof_bytes( - field_bits, - challenge_field_bits, - ¶ms, - child.first_fold_params(), - output_witness_len, - Some(if child_is_terminal { - akita_types::NextWitnessBindingPolicy::TerminalInnerState - } else { - akita_types::NextWitnessBindingPolicy::OuterPayload - }), - )? - .checked_add(eor_bytes) - .ok_or_else(|| { - AkitaError::InvalidSetup("mixed fold proof size overflow".into()) - })?; - let mut folds = Vec::with_capacity(child.folds.len() + 1); - folds.push(CandidateFoldStep { - params: params.clone(), - input_witness_len, - output_witness_len, - estimated_direct_payload_bytes: direct_bytes, - estimated_stage3_payload_bytes: 0, - }); - folds.extend(child.folds.iter().cloned()); - insert_supported( - policy, - &mut frontier, - ScheduleCandidate { - first_direct_setup_field_len: Some( - akita_types::active_setup_field_len( - ¶ms, - &suffix_opening_layout(input_witness_len, None)?, - )?, - ), - total_bytes: direct_bytes - .checked_add(child.total_bytes) - .ok_or_else(|| { - AkitaError::InvalidSetup("mixed proof size overflow".into()) - })?, - setup_field_elements: level_setup_field_elements(¶ms)? - .max(child.setup_field_elements), - folds, - terminal: child.terminal, - }, - ); - } - } - } - } - } - memo.insert(memo_key, frontier.clone()); - Ok(frontier) -} - -pub(crate) fn find_schedule( - key: PolynomialGroupLayout, - policy: &PlannerPolicy, - honest_fold_policy: HonestFoldPolicySpec, - dimensions: &RingDimensionSearchDomain, - ring_challenge_config: impl Fn(usize) -> Result, -) -> Result { - let field_bits = policy.decomposition.field_bits(); - let input_witness_len = 1usize - .checked_shl(key.num_vars() as u32) - .ok_or_else(|| AkitaError::InvalidSetup("mixed root witness too large".into()))?; - let (min_log_basis, max_log_basis) = policy.log_basis_search_range_at_level(0); - let mut memo = MixedMemo::new(); - let mut complete = Vec::new(); - let schedule_key = AkitaScheduleLookupKey::single(key); - - for log_basis in min_log_basis..=max_log_basis { - for root_dimensions in dimensions.candidates() { - let alpha = root_dimensions.d_a().trailing_zeros() as usize; - let reduced_vars = key.num_vars().saturating_sub(alpha); - if reduced_vars == 0 { - continue; - } - let Ok(ring_challenge) = ring_challenge_config(root_dimensions.d_a()) else { - continue; - }; - for (root_params, output_witness_len) in - crate::planner::root_level_candidates_for_basis( - &schedule_key, - honest_fold_policy, - &[], - policy, - *root_dimensions, - &ring_challenge, - &ring_challenge_config, - input_witness_len, - log_basis, - true, - )? - { - let Some(eor_bytes) = try_extension_opening_reduction_level_bytes( - policy.challenge_field_bits()?, - policy.claim_ext_degree, - 0, - key, - input_witness_len, - root_dimensions.d_a(), - )? - else { - continue; - }; - for suffix in suffix_frontier( - policy, - dimensions, - &ring_challenge_config, - key, - 1, - output_witness_len, - log_basis, - *root_dimensions, - akita_types::CommitmentPayloadPhase::CompressedPrefix, - &mut memo, - )? { - let child_is_terminal = suffix.folds.is_empty(); - let root_bytes = level_proof_bytes( - field_bits, - policy.challenge_field_bits()?, - &root_params, - suffix.first_fold_params(), - output_witness_len, - Some(if child_is_terminal { - akita_types::NextWitnessBindingPolicy::TerminalInnerState - } else { - akita_types::NextWitnessBindingPolicy::OuterPayload - }), - )? - .checked_add(eor_bytes) - .ok_or_else(|| { - AkitaError::InvalidSetup("mixed root proof size overflow".into()) - })?; - let mut folds = Vec::with_capacity(suffix.folds.len() + 1); - folds.push(CandidateFoldStep { - params: root_params.clone(), - input_witness_len, - output_witness_len, - estimated_direct_payload_bytes: root_bytes, - estimated_stage3_payload_bytes: 0, - }); - folds.extend(suffix.folds.iter().cloned()); - let candidate = ScheduleCandidate { - first_direct_setup_field_len: None, - total_bytes: root_bytes.checked_add(suffix.total_bytes).ok_or_else( - || AkitaError::InvalidSetup("mixed proof size overflow".into()), - )?, - setup_field_elements: level_setup_field_elements(&root_params)? - .max(suffix.setup_field_elements), - folds, - terminal: suffix.terminal, - }; - if policy.admits_setup_field_elements(candidate.setup_field_elements) { - complete.push(candidate); - } - } - } - } - } - - let Some(selected) = select_complete_candidate(policy, complete.iter())?.cloned() else { - return Err(AkitaError::UnsupportedSchedule(format!( - "no mixed-D schedule with at least two folds for num_vars={}, num_polynomials={}", - key.num_vars(), - key.num_polynomials() - ))); - }; - materialize_candidate_schedule( - selected.total_bytes, - selected.setup_field_elements, - None, - selected.folds, - selected.terminal, - ) -} - -#[cfg(test)] -#[path = "../test/mixed_search.rs"] -mod tests; diff --git a/crates/akita-planner/src/schedule_params/suffix_dp.rs b/crates/akita-planner/src/schedule_params/suffix_dp.rs index 7ada60e4c..2fd0d7ec2 100644 --- a/crates/akita-planner/src/schedule_params/suffix_dp.rs +++ b/crates/akita-planner/src/schedule_params/suffix_dp.rs @@ -13,14 +13,16 @@ use akita_types::{ use crate::{planner::root_level_candidates_for_basis, PlannerPolicy}; use super::{ - derive_candidate_level_params, level_setup_field_elements, stage3_payload_bytes_for_successor, - suffix_opening_layout, terminal_setup_field_elements, CandidateFoldStep, - CandidateTerminalResponse, ScheduleCandidate, MAX_RECURSION_DEPTH, + derive_candidate_level_params, derive_candidate_level_params_all_splits, dimension_candidates, + level_setup_field_elements, stage3_payload_bytes_for_successor, suffix_opening_layout, + terminal_setup_field_elements, CandidateFoldStep, CandidateTerminalResponse, MixedScore, + ScheduleCandidate, }; +use akita_schedules::planner_support::MAX_RECURSION_DEPTH; -/// Result of the suffix DP at one state. Both shape options are reported -/// because the parent's proof-size formula depends on the child's first -/// step: +/// Result of the suffix DP at one state. Each selection objective retains the +/// candidates its parent needs because proof-size and setup-envelope pricing +/// depend on the child's first step: /// /// - `best_by_first_direct_setup_per_lb` — lexicographically best fold-first /// schedule by first direct setup scan and then proof payload, per first-fold @@ -30,10 +32,56 @@ use super::{ /// - `best_by_payload_per_lb` — smallest-payload fold-first schedule per /// first-fold `log_basis`, used after an earlier direct edge has fixed the /// setup-size objective. +/// - `mixed_frontier` — nondominated setup-envelope/proof candidates for the +/// direct adaptive-dimension objective. #[derive(Clone)] pub(crate) struct SuffixResult { pub(crate) best_by_first_direct_setup_per_lb: BTreeMap, pub(crate) best_by_payload_per_lb: BTreeMap, + /// Nondominated setup-envelope/proof candidates used by adaptive scalar + /// planning. Candidates with different first folds remain distinct because + /// the parent proof price and canonical descriptor can distinguish them. + pub(crate) mixed_frontier: Vec, +} + +fn mixed_score(candidate: &ScheduleCandidate) -> MixedScore { + MixedScore { + setup_field_elements: candidate.setup_field_elements, + proof_bytes: candidate.total_bytes, + } +} + +fn dominates_mixed_score(left: MixedScore, right: MixedScore) -> bool { + left.setup_field_elements <= right.setup_field_elements + // A setup-only improvement cannot prune `right`: a parent can mask + // both setup footprints, leaving proof bytes and the descriptor to + // decide the complete schedule. + && left.proof_bytes < right.proof_bytes +} + +fn insert_mixed_frontier( + policy: &PlannerPolicy, + frontier: &mut Vec, + candidate: ScheduleCandidate, +) { + if policy.selection_policy + != crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload + || !policy.admits_setup_field_elements(candidate.setup_field_elements) + { + return; + } + let same_first_fold = + |other: &ScheduleCandidate| other.first_fold_params() == candidate.first_fold_params(); + if frontier.iter().any(|other| { + same_first_fold(other) && dominates_mixed_score(mixed_score(other), mixed_score(&candidate)) + }) { + return; + } + frontier.retain(|other| { + !same_first_fold(other) + || !dominates_mixed_score(mixed_score(&candidate), mixed_score(other)) + }); + frontier.push(candidate); } /// Parent-visible first-fold class. A parent edge prices the child's outgoing @@ -43,6 +91,13 @@ pub(crate) struct SuffixResult { pub(crate) struct FirstFoldKey { log_basis: u32, outer_payload_bytes: usize, + stage3_payload_bytes: usize, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +struct ParentPayloadKey { + outer_payload_bytes: usize, + stage3_payload_bytes: usize, } /// Like [`terminal_direct_suffix_cost`], but returns `None` when the fold at @@ -127,6 +182,9 @@ pub(crate) type ScheduleMemo = HashMap< usize, u32, usize, + usize, + usize, + usize, akita_types::CommitmentPayloadPhase, ), Arc, @@ -181,8 +239,8 @@ fn consider_child_suffixes( edge: &ChildEdge<'_>, child_candidates: &BTreeMap, objectives: ChildObjectives, - best_by_setup: &mut BTreeMap, - best_by_payload: &mut BTreeMap, + best_by_setup: &mut BTreeMap, + best_by_payload: &mut BTreeMap, ) -> Result<(), AkitaError> { for suffix in child_candidates.values() { let Some(candidate) = child_choice(edge, suffix)? else { @@ -199,43 +257,50 @@ fn consider_child_suffixes( Ok(()) } -fn first_outer_payload_bytes( +fn parent_payload_key( policy: &PlannerPolicy, candidate: &ScheduleCandidate, -) -> Result { +) -> Result { let Some(first) = candidate.first_fold_params() else { - return Ok(0); + return Ok(ParentPayloadKey { + outer_payload_bytes: 0, + stage3_payload_bytes: 0, + }); }; - first + let outer_payload_bytes = first .outer_payload_geometry()? .transmitted_coefficients() .checked_mul(akita_types::layout::field_bytes( policy.decomposition.field_bits(), )) - .ok_or_else(|| AkitaError::InvalidSetup("first-fold payload size overflow".into())) + .ok_or_else(|| AkitaError::InvalidSetup("first-fold payload size overflow".into()))?; + Ok(ParentPayloadKey { + outer_payload_bytes, + stage3_payload_bytes: stage3_payload_bytes_for_successor(policy, Some(first))?, + }) } fn update_candidate_frontiers( policy: &PlannerPolicy, candidate: ScheduleCandidate, objectives: ChildObjectives, - best_by_setup: &mut BTreeMap, - best_by_payload: &mut BTreeMap, + best_by_setup: &mut BTreeMap, + best_by_payload: &mut BTreeMap, ) -> Result<(), AkitaError> { - let outer_payload_bytes = first_outer_payload_bytes(policy, &candidate)?; + let parent_key = parent_payload_key(policy, &candidate)?; let improves_setup = objectives.first_direct_setup_then_payload - && best_by_setup.get(&outer_payload_bytes).is_none_or(|best| { + && best_by_setup.get(&parent_key).is_none_or(|best| { candidate.recursive_setup_frontier_score() < best.recursive_setup_frontier_score() }); let improves_payload = objectives.payload && best_by_payload - .get(&outer_payload_bytes) + .get(&parent_key) .is_none_or(|best| candidate.direct_frontier_score() < best.direct_frontier_score()); if improves_setup { - best_by_setup.insert(outer_payload_bytes, candidate.clone()); + best_by_setup.insert(parent_key, candidate.clone()); } if improves_payload { - best_by_payload.insert(outer_payload_bytes, candidate); + best_by_payload.insert(parent_key, candidate); } Ok(()) } @@ -314,10 +379,25 @@ fn child_choice( })) } +fn consider_mixed_child_suffixes( + edge: &ChildEdge<'_>, + child_candidates: &[ScheduleCandidate], + frontier: &mut Vec, +) -> Result<(), AkitaError> { + for suffix in child_candidates { + let Some(candidate) = child_choice(edge, suffix)? else { + continue; + }; + insert_mixed_frontier(edge.policy, frontier, candidate); + } + Ok(()) +} + fn empty_suffix_result() -> Arc { Arc::new(SuffixResult { best_by_first_direct_setup_per_lb: BTreeMap::new(), best_by_payload_per_lb: BTreeMap::new(), + mixed_frontier: Vec::new(), }) } @@ -347,6 +427,7 @@ pub(crate) struct SuffixState { pub(crate) current_witness_len: usize, pub(crate) current_lb: u32, pub(crate) incoming_setup_prefix: Option, + pub(crate) dimension_ceiling: CommitmentRingDims, pub(crate) payload_phase: akita_types::CommitmentPayloadPhase, } @@ -358,6 +439,9 @@ impl SuffixState { usize, u32, usize, + usize, + usize, + usize, akita_types::CommitmentPayloadPhase, ) { ( @@ -365,6 +449,9 @@ impl SuffixState { self.current_witness_len, self.current_lb, self.incoming_setup_prefix.unwrap_or(0), + self.dimension_ceiling.d_a(), + self.dimension_ceiling.d_b(), + self.dimension_ceiling.d_d(), self.payload_phase, ) } @@ -381,15 +468,26 @@ fn price_level_candidate_with_children( direct_child: &SuffixResult, offloaded_child: Option<&SuffixResult>, require_child_fold: bool, - best_for_this_lb: &mut BTreeMap, - best_payload_for_this_lb: &mut BTreeMap, + best_for_this_lb: &mut BTreeMap, + best_payload_for_this_lb: &mut BTreeMap, + mixed_frontier: &mut Vec, ) -> Result<(), AkitaError> { let policy = ctx.policy; // Branch A: terminate directly on the witness entering this state. // There is no alternative terminal-shaped predecessor output: the // predecessor produces one canonical witness, and the terminal inner // commitment consumes that exact witness. - if !(ctx.level_zero_is_root && state.level == 0) + let adaptive_terminal_is_allowed = !matches!( + policy.ring_dimension_schedule_mode, + crate::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + .. + } if policy.selection_policy + == crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload + && state.level < num_search_levels + ); + if adaptive_terminal_is_allowed + && !(ctx.level_zero_is_root && state.level == 0) && state.incoming_setup_prefix.is_none() && !candidate_params.has_precommitted_groups() { @@ -418,7 +516,7 @@ fn price_level_candidate_with_children( }; update_candidate_frontiers( policy, - candidate, + candidate.clone(), ChildObjectives { first_direct_setup_then_payload: true, payload: true, @@ -426,6 +524,7 @@ fn price_level_candidate_with_children( best_for_this_lb, best_payload_for_this_lb, )?; + insert_mixed_frontier(policy, mixed_frontier, candidate); } } @@ -452,6 +551,7 @@ fn price_level_candidate_with_children( best_for_this_lb, best_payload_for_this_lb, )?; + consider_mixed_child_suffixes(&direct_edge, &direct_child.mixed_frontier, mixed_frontier)?; if let Some(offloaded_child) = offloaded_child { let offloaded_edge = ChildEdge { offloaded: true, @@ -516,6 +616,7 @@ pub(crate) fn derive_optimal_suffix_schedule( current_witness_len, current_lb, incoming_setup_prefix, + dimension_ceiling, payload_phase, } = state; let memo_key = state.memo_key(); @@ -534,6 +635,7 @@ pub(crate) fn derive_optimal_suffix_schedule( let mut best_by_first_direct_setup_per_lb: BTreeMap = BTreeMap::new(); let mut best_by_payload_per_lb: BTreeMap = BTreeMap::new(); + let mut mixed_frontier = Vec::new(); let root_level_key = root_lookup_key.filter(|_| level == 0); if root_level_key.is_some() && incoming_setup_prefix.is_some() { return Err(AkitaError::InvalidSetup( @@ -569,19 +671,6 @@ pub(crate) fn derive_optimal_suffix_schedule( PolynomialGroupLayout::singleton(num_vars) } }); - let Some(eor_bytes) = try_extension_opening_reduction_level_bytes( - policy.challenge_field_bits()?, - policy.claim_ext_degree, - level, - eor_key, - current_witness_len, - policy.uniform_ring_dimension, - )? - else { - let result = empty_suffix_result(); - memo.insert(memo_key, Arc::clone(&result)); - return Ok(result); - }; let scalar_opening_layout = if root_level_key.is_some() { None } else { @@ -595,8 +684,8 @@ pub(crate) fn derive_optimal_suffix_schedule( if lb < current_lb { continue; } - let mut best_for_this_lb = BTreeMap::::new(); - let mut best_payload_for_this_lb = BTreeMap::::new(); + let mut best_for_this_lb = BTreeMap::::new(); + let mut best_payload_for_this_lb = BTreeMap::::new(); let (current_opening_layout, candidates, require_child_fold) = if let Some(root_key) = root_level_key @@ -604,23 +693,53 @@ pub(crate) fn derive_optimal_suffix_schedule( let current_opening_layout = root_opening_layout.as_ref().ok_or_else(|| { AkitaError::InvalidSetup("root batch opening layout is missing".to_string()) })?; - let dimensions = CommitmentRingDims::uniform(policy.uniform_ring_dimension); - let candidates = root_level_candidates_for_basis( - root_key, - root_honest_fold_policy.ok_or_else(|| { - AkitaError::InvalidSetup( - "root batch is missing its honest fold policy".to_string(), - ) - })?, - precommitted_honest_fold_policies, - policy, - dimensions, - default_ring_challenge_cfg, - ring_challenge_config, - current_witness_len, - lb, - true, - )?; + let mut candidates = Vec::new(); + for dimensions in dimension_candidates(policy, level, dimension_ceiling)? { + let Some(eor_bytes) = try_extension_opening_reduction_level_bytes( + policy.challenge_field_bits()?, + policy.claim_ext_degree, + level, + eor_key, + current_witness_len, + dimensions.inner(), + )? + else { + continue; + }; + let ring_challenge_cfg = match dimensions { + akita_schedules::planner_support::RingDimensionCandidate::Fixed(value) + if value == CommitmentRingDims::uniform(policy.uniform_ring_dimension) => + { + *default_ring_challenge_cfg + } + _ => { + let Ok(config) = ring_challenge_config(dimensions.inner()) else { + continue; + }; + config + } + }; + candidates.extend( + root_level_candidates_for_basis( + root_key, + root_honest_fold_policy.ok_or_else(|| { + AkitaError::InvalidSetup( + "root batch is missing its honest fold policy".to_string(), + ) + })?, + precommitted_honest_fold_policies, + policy, + dimensions, + &ring_challenge_cfg, + ring_challenge_config, + current_witness_len, + lb, + true, + )? + .into_iter() + .map(|(params, next_witness_len)| (params, next_witness_len, eor_bytes)), + ); + } ( current_opening_layout, candidates, @@ -628,22 +747,61 @@ pub(crate) fn derive_optimal_suffix_schedule( ) } else { let mut candidates = Vec::new(); - let dimensions = CommitmentRingDims::uniform(policy.uniform_ring_dimension); - let Ok(ring_challenge_cfg) = ring_challenge_config(dimensions.d_a()) else { - continue; - }; - for &mode in payload_phase.candidate_modes(level, incoming_setup_prefix.is_some()) { - if let Some(candidate) = derive_candidate_level_params( - policy, - mode, - &ring_challenge_cfg, - dimensions, - current_witness_len, - lb, + let exhaustive_splits = matches!( + policy.ring_dimension_schedule_mode, + crate::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + .. + } if level < num_search_levels + ); + for dimensions in dimension_candidates(policy, level, dimension_ceiling)? { + let Some(eor_bytes) = try_extension_opening_reduction_level_bytes( + policy.challenge_field_bits()?, + policy.claim_ext_degree, level, - incoming_setup_prefix, - )? { - candidates.push(candidate); + eor_key, + current_witness_len, + dimensions.inner(), + )? + else { + continue; + }; + let Ok(ring_challenge_cfg) = ring_challenge_config(dimensions.inner()) else { + continue; + }; + for &mode in payload_phase.candidate_modes(level, incoming_setup_prefix.is_some()) { + let level_candidates = if exhaustive_splits { + derive_candidate_level_params_all_splits( + policy, + mode, + &ring_challenge_cfg, + dimensions, + current_witness_len, + lb, + level, + incoming_setup_prefix, + )? + } else { + derive_candidate_level_params( + policy, + mode, + &ring_challenge_cfg, + dimensions, + current_witness_len, + lb, + level, + incoming_setup_prefix, + )? + .into_iter() + .collect() + }; + candidates.extend( + level_candidates + .into_iter() + .map(|(params, next_witness_len)| { + (params, next_witness_len, eor_bytes) + }), + ); } } if candidates.is_empty() { @@ -658,7 +816,7 @@ pub(crate) fn derive_optimal_suffix_schedule( ) }; - for (candidate_params, next_witness_len) in candidates { + for (candidate_params, next_witness_len, eor_bytes) in candidates { if let Some(natural_prefix_len) = incoming_setup_prefix { let padded_prefix_len = akita_types::padded_setup_prefix_len(natural_prefix_len); if !offloaded_witness_contracts( @@ -682,6 +840,7 @@ pub(crate) fn derive_optimal_suffix_schedule( current_witness_len: next_witness_len, current_lb: lb, incoming_setup_prefix: None, + dimension_ceiling: candidate_params.role_dims(), payload_phase: payload_phase.after(candidate_params.payload_mode), }, depth + 1, @@ -697,6 +856,7 @@ pub(crate) fn derive_optimal_suffix_schedule( current_witness_len: next_witness_len, current_lb: lb, incoming_setup_prefix: Some(natural_len), + dimension_ceiling: candidate_params.role_dims(), payload_phase, }, depth + 1, @@ -716,10 +876,11 @@ pub(crate) fn derive_optimal_suffix_schedule( require_child_fold, &mut best_for_this_lb, &mut best_payload_for_this_lb, + &mut mixed_frontier, )?; } - for (outer_payload_bytes, choice) in best_for_this_lb { + for (parent_key, choice) in best_for_this_lb { let ScheduleCandidate { first_direct_setup_field_len, total_bytes, @@ -730,7 +891,8 @@ pub(crate) fn derive_optimal_suffix_schedule( best_by_first_direct_setup_per_lb.insert( FirstFoldKey { log_basis: lb, - outer_payload_bytes, + outer_payload_bytes: parent_key.outer_payload_bytes, + stage3_payload_bytes: parent_key.stage3_payload_bytes, }, ScheduleCandidate { total_bytes, @@ -741,7 +903,7 @@ pub(crate) fn derive_optimal_suffix_schedule( }, ); } - for (outer_payload_bytes, choice) in best_payload_for_this_lb { + for (parent_key, choice) in best_payload_for_this_lb { let ScheduleCandidate { first_direct_setup_field_len, total_bytes, @@ -752,7 +914,8 @@ pub(crate) fn derive_optimal_suffix_schedule( best_by_payload_per_lb.insert( FirstFoldKey { log_basis: lb, - outer_payload_bytes, + outer_payload_bytes: parent_key.outer_payload_bytes, + stage3_payload_bytes: parent_key.stage3_payload_bytes, }, ScheduleCandidate { total_bytes, @@ -768,6 +931,7 @@ pub(crate) fn derive_optimal_suffix_schedule( let result = Arc::new(SuffixResult { best_by_first_direct_setup_per_lb, best_by_payload_per_lb, + mixed_frontier, }); memo.insert(memo_key, Arc::clone(&result)); Ok(result) diff --git a/crates/akita-planner/src/test/mixed_search.rs b/crates/akita-planner/src/test/mixed_search.rs deleted file mode 100644 index 2fdb5d5d5..000000000 --- a/crates/akita-planner/src/test/mixed_search.rs +++ /dev/null @@ -1,47 +0,0 @@ -use super::{dominates_score, MixedScore}; - -#[test] -fn frontier_keeps_lower_payload_child_until_parent_masks_setup() { - let lower_setup = MixedScore { - setup_field_elements: 10, - proof_bytes: 20, - }; - let lower_payload = MixedScore { - setup_field_elements: 15, - proof_bytes: 10, - }; - assert!(!dominates_score(lower_setup, lower_payload)); - assert!(!dominates_score(lower_payload, lower_setup)); - - let parent_setup = 20; - let lower_setup_complete = MixedScore { - setup_field_elements: parent_setup.max(lower_setup.setup_field_elements), - proof_bytes: lower_setup.proof_bytes, - }; - let lower_payload_complete = MixedScore { - setup_field_elements: parent_setup.max(lower_payload.setup_field_elements), - proof_bytes: lower_payload.proof_bytes, - }; - assert!(lower_payload_complete < lower_setup_complete); -} - -#[test] -fn frontier_keeps_equal_payload_alternatives_for_descriptor_ties() { - let lower_setup = MixedScore { - setup_field_elements: 10, - proof_bytes: 20, - }; - let higher_setup = MixedScore { - setup_field_elements: 15, - proof_bytes: 20, - }; - - assert!(!dominates_score(lower_setup, higher_setup)); - assert!(!dominates_score(higher_setup, lower_setup)); - - let parent_setup = 20; - assert_eq!( - parent_setup.max(lower_setup.setup_field_elements), - parent_setup.max(higher_setup.setup_field_elements) - ); -} diff --git a/crates/akita-planner/src/test/schedule_params.rs b/crates/akita-planner/src/test/schedule_params.rs index efcd01e57..f5d1dc4c5 100644 --- a/crates/akita-planner/src/test/schedule_params.rs +++ b/crates/akita-planner/src/test/schedule_params.rs @@ -25,14 +25,44 @@ fn policy_for_domain( mut policy: PlannerPolicy, domain: &RingDimensionSearchDomain, ) -> PlannerPolicy { - policy.ring_dimension_candidates = Box::leak(domain.candidates().to_vec().into_boxed_slice()); let is_uniform = domain.candidates() == [CommitmentRingDims::uniform(policy.uniform_ring_dimension)]; - policy.selection_policy = if is_uniform { - crate::SelectionPolicyId::MinEstimatedProofPayload + policy.ring_dimension_schedule_mode = if is_uniform { + crate::RingDimensionScheduleMode::UniformDimension { + ring_dimension: policy.uniform_ring_dimension, + } } else { - crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload + let mut a = domain + .candidates() + .iter() + .map(|dims| dims.d_a()) + .collect::>(); + let mut b = domain + .candidates() + .iter() + .map(|dims| dims.d_b()) + .collect::>(); + let mut d = domain + .candidates() + .iter() + .map(|dims| dims.d_d()) + .collect::>(); + for dimensions in [&mut a, &mut b, &mut d] { + dimensions.sort_unstable(); + dimensions.dedup(); + } + crate::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels: 2, + uniform_suffix_dimension: 64, + potential_a_dimensions: Box::leak(a.into_boxed_slice()), + potential_b_dimensions: Box::leak(b.into_boxed_slice()), + potential_d_dimensions: Box::leak(d.into_boxed_slice()), + } }; + policy.selection_policy = crate::SelectionPolicyId::for_policy( + policy.recursive_setup_planning, + policy.ring_dimension_schedule_mode, + ); policy } @@ -87,9 +117,9 @@ fn ring_dimension_domain_is_canonical_and_rejects_invalid_carriers() { #[cfg(feature = "catalog-gen")] #[test] fn mixed_domain_search_beats_or_ties_uniform_d64() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; - let base_policy = policy_of::(); + let base_policy = policy_of::(); let dimensions = [ CommitmentRingDims::uniform(64), CommitmentRingDims { @@ -104,9 +134,9 @@ fn mixed_domain_search_beats_or_ties_uniform_d64() { let selected = find_schedule( key, &policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap(); let selected_score = ( @@ -118,17 +148,17 @@ fn mixed_domain_search_beats_or_ties_uniform_d64() { ); let uniform = RingDimensionSearchDomain::uniform(dimensions[0].d_a()).unwrap(); - let mut uniform_policy = policy_of::(); + let mut uniform_policy = policy_of::(); uniform_policy.uniform_ring_dimension = dimensions[0].d_a(); - uniform_policy.ring_dimension_candidates = - Box::leak(uniform.candidates().to_vec().into_boxed_slice()); + uniform_policy.ring_dimension_schedule_mode = + crate::RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }; uniform_policy.selection_policy = crate::SelectionPolicyId::MinEstimatedProofPayload; let candidate = find_schedule( key, &uniform_policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &uniform, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap(); assert!( @@ -150,72 +180,26 @@ fn mixed_domain_search_beats_or_ties_uniform_d64() { for (index, fold) in schedule.recursive_folds.iter().enumerate() { let current = fold.params.witness.role_dims(); assert!(componentwise_dimensions_at_most(current, previous)); - if index + 1 >= MIXED_SEARCH_FOLD_LEVELS { + if index + 1 >= akita_schedules::ADAPTIVE_SEARCH_LEVELS { assert_eq!( current, - CommitmentRingDims::uniform(MIXED_SEARCH_SUFFIX_RING_DIMENSION) + CommitmentRingDims::uniform(ADAPTIVE_SUFFIX_RING_DIMENSION) ); } previous = current; } assert_eq!( schedule.terminal.params.witness.d_a(), - MIXED_SEARCH_SUFFIX_RING_DIMENSION - ); -} - -#[cfg(feature = "catalog-gen")] -#[test] -fn grouped_scalar_fallback_preserves_mixed_domain() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; - use akita_types::AkitaScheduleLookupKey; - - let base_policy = policy_of::(); - let dimensions = [ - CommitmentRingDims::uniform(64), - CommitmentRingDims { - inner: 128, - outer: 64, - opening: 64, - }, - ]; - let domain = RingDimensionSearchDomain::new(dimensions).unwrap(); - let policy = policy_for_domain(base_policy, &domain); - let key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::singleton(16)); - - let grouped = crate::find_schedule( - &key, - D256OneHot::root_honest_fold_policy(), - &[], - &policy, - D256OneHot::ring_challenge_config, - ) - .unwrap(); - let direct = mixed_search::find_schedule( - key.final_group, - &policy, - D256OneHot::root_honest_fold_policy(), - &domain, - D256OneHot::ring_challenge_config, - ) - .unwrap(); - - assert_eq!( - grouped.schedule.canonical_descriptor_bytes(), - direct.schedule.canonical_descriptor_bytes() - ); - assert_eq!( - grouped.estimate.estimated_proof_payload_bytes(), - direct.estimate.estimated_proof_payload_bytes() + ADAPTIVE_SUFFIX_RING_DIMENSION ); } #[cfg(feature = "catalog-gen")] #[test] -fn pruned_mixed_search_matches_unpruned_traversal_and_is_canonical() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; +fn adaptive_dimension_search_is_canonical() { + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; - let base_policy = policy_of::(); + let base_policy = policy_of::(); let d64 = CommitmentRingDims::uniform(64); let a128 = CommitmentRingDims { inner: 128, @@ -230,43 +214,21 @@ fn pruned_mixed_search_matches_unpruned_traversal_and_is_canonical() { let selected = find_schedule( key, &policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &reversed_with_duplicate, - D256OneHot::ring_challenge_config, - ) - .unwrap(); - let unpruned = unpruned_search::find_schedule( - key, - &policy, - D256OneHot::root_honest_fold_policy(), - &canonical, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap(); let repeated = find_schedule( key, &policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &canonical, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap(); - assert_eq!( - ( - selected.estimate.estimated_num_setup_field_elements, - selected.estimate.estimated_proof_payload_bytes().unwrap(), - ), - ( - unpruned.estimate.estimated_num_setup_field_elements, - unpruned.estimate.estimated_proof_payload_bytes().unwrap(), - ) - ); let selected_descriptor = selected.schedule.canonical_descriptor_bytes(); - assert_eq!( - selected_descriptor, - unpruned.schedule.canonical_descriptor_bytes() - ); assert_eq!( selected_descriptor, repeated.schedule.canonical_descriptor_bytes() @@ -275,25 +237,27 @@ fn pruned_mixed_search_matches_unpruned_traversal_and_is_canonical() { #[test] fn uniform_suffix_dp_matches_unpruned_exact_cutover_search() { - use akita_config::{policy_of, proof_optimized::fp128::D64OneHot, CommitmentConfig}; + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; let domain = RingDimensionSearchDomain::uniform(64).unwrap(); - let policy = policy_for_domain(policy_of::(), &domain); + let mut base_policy = policy_of::(); + base_policy.uniform_ring_dimension = 64; + let policy = policy_for_domain(base_policy, &domain); let key = PolynomialGroupLayout::singleton(16); let selected = find_schedule( key, &policy, - D64OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D64OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap(); let unpruned = unpruned_search::find_schedule( key, &policy, - D64OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D64OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap(); @@ -309,13 +273,60 @@ fn uniform_suffix_dp_matches_unpruned_exact_cutover_search() { #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_parallel_generation_is_descriptor_deterministic() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; +fn adaptive_frontier_matches_unpruned_l0_l1_search() { + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; + + let domain = RingDimensionSearchDomain::new([ + CommitmentRingDims::uniform(64), + CommitmentRingDims { + inner: 128, + outer: 64, + opening: 64, + }, + ]) + .expect("representative adaptive domain"); + let policy = policy_for_domain(policy_of::(), &domain); + let key = PolynomialGroupLayout::singleton(16); + let selected = find_schedule( + key, + &policy, + OneHot::root_honest_fold_policy(), + &domain, + OneHot::ring_challenge_config, + ) + .expect("frontier search"); + let unpruned = unpruned_search::find_schedule( + key, + &policy, + OneHot::root_honest_fold_policy(), + &domain, + OneHot::ring_challenge_config, + ) + .expect("unpruned adaptive search"); + + assert_eq!( + selected.estimate.estimated_num_setup_field_elements, + unpruned.estimate.estimated_num_setup_field_elements + ); + assert_eq!( + selected.estimate.estimated_proof_payload_bytes().unwrap(), + unpruned.estimate.estimated_proof_payload_bytes().unwrap() + ); + assert_eq!( + selected.schedule.canonical_descriptor_bytes(), + unpruned.schedule.canonical_descriptor_bytes() + ); +} + +#[cfg(feature = "catalog-gen")] +#[test] +fn adaptive_search_parallel_generation_is_descriptor_deterministic() { + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; let handles = (0..8) .map(|_| { std::thread::spawn(|| { - let base_policy = policy_of::(); + let base_policy = policy_of::(); let domain = RingDimensionSearchDomain::new([ CommitmentRingDims { inner: 128, @@ -329,9 +340,9 @@ fn mixed_search_parallel_generation_is_descriptor_deterministic() { find_schedule( PolynomialGroupLayout::singleton(16), &policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .expect("parallel mixed planner run") .schedule @@ -349,9 +360,9 @@ fn mixed_search_parallel_generation_is_descriptor_deterministic() { #[cfg(feature = "catalog-gen")] #[test] fn mixed_root_prices_eor_at_candidate_a_dimension() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; - let mut policy = policy_of::(); + let mut policy = policy_of::(); // D256 enables root projection at this width while the D64 candidate does not. policy.claim_ext_degree = 64; let candidate_dimensions = CommitmentRingDims::uniform(64); @@ -362,9 +373,9 @@ fn mixed_root_prices_eor_at_candidate_a_dimension() { let selected = find_schedule( key, &policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .expect("mixed planner boundary schedule"); let schedule = &selected.schedule; @@ -419,42 +430,33 @@ fn mixed_root_prices_eor_at_candidate_a_dimension() { #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_skips_an_unsupported_sis_candidate_and_keeps_its_sibling() { - use akita_config::{policy_of, proof_optimized::fp128::D512OneHot, CommitmentConfig}; +fn adaptive_search_rejects_an_advertised_unsupported_role_dimension() { + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; - let base_policy = policy_of::(); + let mut base_policy = policy_of::(); + base_policy.uniform_ring_dimension = 512; let d64 = CommitmentRingDims::uniform(64); let unsupported_uniform_d512 = CommitmentRingDims::uniform(512); let domain = RingDimensionSearchDomain::new([d64, unsupported_uniform_d512]).expect("mixed domain"); let policy = policy_for_domain(base_policy, &domain); - let selected = find_schedule( + let error = find_schedule( PolynomialGroupLayout::singleton(16), &policy, - D512OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D512OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) - .expect("the supported D64 sibling must survive"); - - assert_eq!( - selected - .schedule - .root - .params - .final_group - .commitment - .role_dims(), - d64 - ); + .expect_err("an unsupported advertised B/D dimension must reject the policy"); + assert!(error.to_string().contains("scheduled B dimension D512")); } #[cfg(feature = "catalog-gen")] #[test] -fn mixed_nv36_benchmark_policy_selects_minimum_setup_schedule() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; +fn adaptive_nv36_minimizes_setup_before_proof_bytes() { + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; - let base_policy = policy_of::(); + let base_policy = policy_of::(); let d64 = CommitmentRingDims::uniform(64); let d128_mixed = CommitmentRingDims { inner: 128, @@ -473,22 +475,21 @@ fn mixed_nv36_benchmark_policy_selects_minimum_setup_schedule() { let selected = find_schedule( PolynomialGroupLayout::singleton(36), &policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .expect("nv36 mixed planner"); let rank_one_capped_domain = RingDimensionSearchDomain::new([d64, d128_mixed, d128]) .expect("rank-one-capped comparison domain"); - let mut comparison_policy = - policy_for_domain(policy_of::(), &rank_one_capped_domain); + let mut comparison_policy = policy_for_domain(policy_of::(), &rank_one_capped_domain); comparison_policy.setup_field_budget = None; let rank_one_capped = find_schedule( PolynomialGroupLayout::singleton(36), &comparison_policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &rank_one_capped_domain, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .expect("rank-one-capped nv36 planner"); let selected_root = &selected.schedule.root.params.final_group.commitment; @@ -500,18 +501,7 @@ fn mixed_nv36_benchmark_policy_selects_minimum_setup_schedule() { .params .witness .role_dims(), - CommitmentRingDims::uniform(64) - ); - assert_eq!( - selected - .estimate - .estimated_num_setup_field_elements - .div_ceil(policy.uniform_ring_dimension), - 176_128 - ); - assert_eq!( - selected.estimate.estimated_proof_payload_bytes().unwrap(), - 90_312 + d64 ); assert_eq!(rank_one_capped_root.inner_commit_matrix.output_rank(), 3); assert_eq!(selected_root.inner_commit_matrix.output_rank(), 1); @@ -525,29 +515,27 @@ fn mixed_nv36_benchmark_policy_selects_minimum_setup_schedule() { assert!( selected.estimate.estimated_num_setup_field_elements < rank_one_capped.estimate.estimated_num_setup_field_elements, - "the rank-two D256 candidate must beat the rank-one-capped search on setup" + "the D256-root candidate must beat the restricted domain on setup fields" ); } #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_requires_a_monotonic_d64_suffix_domain() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; +fn adaptive_search_requires_a_monotonic_d64_suffix_domain() { + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; - let base_policy = policy_of::(); + let base_policy = policy_of::(); let missing_d64 = RingDimensionSearchDomain::new([CommitmentRingDims::uniform(128)]).unwrap(); let missing_policy = policy_for_domain(base_policy, &missing_d64); let error = find_schedule( PolynomialGroupLayout::singleton(16), &missing_policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &missing_d64, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap_err(); - assert!(error - .to_string() - .contains("requires the D64 uniform candidate")); + assert!(error.to_string().contains("must contain suffix D64")); let below_d64 = RingDimensionSearchDomain::new([ CommitmentRingDims::uniform(64), @@ -562,42 +550,70 @@ fn mixed_search_requires_a_monotonic_d64_suffix_domain() { let error = find_schedule( PolynomialGroupLayout::singleton(16), &below_policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &below_d64, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap_err(); - assert!(error.to_string().contains("component-wise at least D64")); + assert!(error.to_string().contains("scheduled B dimension D32")); } #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_rejects_direct_multi_chunk_policy() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; +fn adaptive_search_supports_direct_multi_chunk_policy() { + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; - let mut policy = policy_of::(); + let mut policy = policy_of::(); policy.witness_chunk = akita_types::ChunkedWitnessCfg::d64_production(); - let domain = RingDimensionSearchDomain::new([CommitmentRingDims::uniform(64)]).unwrap(); + let domain = RingDimensionSearchDomain::new([ + CommitmentRingDims::uniform(64), + CommitmentRingDims::uniform(128), + CommitmentRingDims::uniform(256), + ]) + .unwrap(); policy = policy_for_domain(policy, &domain); - let error = find_schedule( + let schedule = find_schedule( PolynomialGroupLayout::singleton(16), &policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) - .unwrap_err(); - assert!(error - .to_string() - .contains("does not yet support direct multi-chunk planning")); + .unwrap(); + assert!(!schedule.schedule.recursive_folds.is_empty()); + assert_eq!( + schedule + .schedule + .root + .params + .final_group + .commitment + .witness_chunk + .num_chunks, + 8 + ); + assert_eq!( + schedule.schedule.recursive_folds[0] + .params + .witness + .witness_chunk + .num_chunks, + 8 + ); + assert!(schedule + .schedule + .recursive_folds + .iter() + .skip(1) + .all(|fold| fold.params.witness.witness_chunk.num_chunks == 1)); } #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_validates_key_and_policy_at_entry() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; +fn adaptive_search_validates_key_and_policy_at_entry() { + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; - let base_policy = policy_of::(); + let base_policy = policy_of::(); let domain = RingDimensionSearchDomain::new([ CommitmentRingDims::uniform(64), CommitmentRingDims::uniform(base_policy.uniform_ring_dimension), @@ -608,9 +624,9 @@ fn mixed_search_validates_key_and_policy_at_entry() { let error = find_schedule( PolynomialGroupLayout::new(16, 0), &policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap_err(); assert!(error @@ -622,9 +638,9 @@ fn mixed_search_validates_key_and_policy_at_entry() { let error = find_schedule( PolynomialGroupLayout::singleton(16), &invalid_policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap_err(); assert!(error @@ -634,23 +650,43 @@ fn mixed_search_validates_key_and_policy_at_entry() { #[cfg(feature = "catalog-gen")] #[test] -fn dimension_domain_is_independent_of_setup_generation_dimension() { - use akita_config::{policy_of, proof_optimized::fp128::D128OneHot}; - - let mut policy = policy_of::(); - let domain = RingDimensionSearchDomain::uniform(256).unwrap(); - policy.uniform_ring_dimension = 256; - policy.ring_dimension_candidates = Box::leak(domain.candidates().to_vec().into_boxed_slice()); - policy.selection_policy = crate::SelectionPolicyId::MinEstimatedProofPayload; +fn adaptive_root_domain_is_independent_of_uniform_config_dimension() { + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; + + let domain = RingDimensionSearchDomain::new([ + CommitmentRingDims::uniform(64), + CommitmentRingDims { + inner: 256, + outer: 64, + opening: 64, + }, + ]) + .expect("supported fp128 adaptive domain"); + let mut base_policy = policy_of::(); + base_policy.uniform_ring_dimension = 64; + let policy = policy_for_domain(base_policy, &domain); domain.validate_for_policy(&policy).unwrap(); + + let selected = find_schedule( + PolynomialGroupLayout::singleton(36), + &policy, + OneHot::root_honest_fold_policy(), + &domain, + OneHot::ring_challenge_config, + ) + .expect("D256 A search must not be capped by uniform D64"); + assert_eq!( + selected.schedule.root.params.final_group.commitment.d_a(), + 256 + ); } #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_applies_setup_budget_in_physical_fields() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; +fn adaptive_search_applies_setup_budget_in_physical_fields() { + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; - let mut policy = policy_of::(); + let mut policy = policy_of::(); let domain = RingDimensionSearchDomain::new([ CommitmentRingDims::uniform(64), CommitmentRingDims { @@ -664,9 +700,9 @@ fn mixed_search_applies_setup_budget_in_physical_fields() { let selected = find_schedule( PolynomialGroupLayout::singleton(16), &policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap(); let exact_fields = @@ -676,9 +712,9 @@ fn mixed_search_applies_setup_budget_in_physical_fields() { let error = find_schedule( PolynomialGroupLayout::singleton(16), &policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap_err(); assert!(error.to_string().contains("no mixed-D schedule")); @@ -687,18 +723,20 @@ fn mixed_search_applies_setup_budget_in_physical_fields() { #[cfg(feature = "catalog-gen")] #[test] fn exact_payload_ties_prefer_the_smaller_setup_envelope() { - use akita_config::{ - policy_of, proof_optimized::fp128::D64OneHotMultiChunkW4R2, CommitmentConfig, - }; + use akita_config::{policy_of, proof_optimized::fp128::OneHotMultiChunkW4R2, CommitmentConfig}; - let policy = policy_of::(); let domain = RingDimensionSearchDomain::uniform(64).unwrap(); + // Production W4R2 is adaptive now. Keep this regression on its original + // fixed-D64 domain, where two equal-payload schedules differ in setup size. + let mut base_policy = policy_of::(); + base_policy.uniform_ring_dimension = 64; + let policy = policy_for_domain(base_policy, &domain); let selected = find_schedule( PolynomialGroupLayout::singleton(32), &policy, - D64OneHotMultiChunkW4R2::root_honest_fold_policy(), + OneHotMultiChunkW4R2::root_honest_fold_policy(), &domain, - D64OneHotMultiChunkW4R2::ring_challenge_config, + OneHotMultiChunkW4R2::ring_challenge_config, ) .expect("W4R2 schedule"); @@ -716,27 +754,21 @@ fn exact_payload_ties_prefer_the_smaller_setup_envelope() { #[test] fn recursive_exact_cutover_proof_size_is_documented() { use akita_config::{ - policy_of, proof_optimized::fp128::D64OneHot, CommitmentConfig, RecursiveCommitmentConfig, + policy_of, proof_optimized::fp128::OneHot, CommitmentConfig, RecursiveCommitmentConfig, }; - use akita_types::{AkitaScheduleLookupKey, CommittedGroupProfile}; + use akita_types::AkitaScheduleLookupKey; - type Recursive = RecursiveCommitmentConfig; + type Recursive = RecursiveCommitmentConfig; let precommit_layout = PolynomialGroupLayout::singleton(16); - let precommit_policy = policy_of::(); - let precommit_domain = - RingDimensionSearchDomain::uniform(precommit_policy.uniform_ring_dimension).unwrap(); - let precommit = find_schedule( + let descriptor = derive_standalone_precommit_profile( precommit_layout, - &precommit_policy, - D64OneHot::root_honest_fold_policy(), - &precommit_domain, - D64OneHot::ring_challenge_config, + &policy_of::(), + OneHot::root_honest_fold_policy(), + OneHot::ring_challenge_config, ) .unwrap(); - let descriptor = CommittedGroupProfile::from_params( - precommit_layout, - &precommit.schedule.root.params.final_group.commitment, - ); + assert_eq!(descriptor.inner_commit_matrix.ring_dimension(), 64); + assert_eq!(descriptor.outer_commit_matrix.ring_dimension(), 64); let key = AkitaScheduleLookupKey { final_group: PolynomialGroupLayout::new(32, 2), precommitteds: vec![descriptor, descriptor], @@ -745,8 +777,8 @@ fn recursive_exact_cutover_proof_size_is_documented() { &key, Recursive::root_honest_fold_policy(), &[ - D64OneHot::root_honest_fold_policy(), - D64OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), ], &policy_of::(), Recursive::ring_challenge_config, @@ -755,6 +787,120 @@ fn recursive_exact_cutover_proof_size_is_documented() { assert_eq!( planned.estimate.estimated_proof_payload_bytes().unwrap(), - 94_680 + 96_876 ); } + +#[cfg(feature = "catalog-gen")] +#[test] +fn recursive_adaptive_search_selects_schedule_dimensions_and_setup_prefixes() { + use akita_config::{ + policy_of, proof_optimized::fp128::OneHot, CommitmentConfig, RecursiveCommitmentConfig, + }; + use akita_types::AkitaScheduleLookupKey; + + let precommit_layout = PolynomialGroupLayout::singleton(16); + let descriptor = derive_standalone_precommit_profile( + precommit_layout, + &policy_of::(), + OneHot::root_honest_fold_policy(), + OneHot::ring_challenge_config, + ) + .unwrap(); + assert_eq!(descriptor.inner_commit_matrix.ring_dimension(), 64); + assert_eq!(descriptor.outer_commit_matrix.ring_dimension(), 64); + let key = AkitaScheduleLookupKey { + final_group: PolynomialGroupLayout::new(32, 2), + precommitteds: vec![descriptor, descriptor], + }; + type Recursive = RecursiveCommitmentConfig; + let planned = crate::find_schedule( + &key, + Recursive::root_honest_fold_policy(), + &[ + OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), + ], + &policy_of::(), + Recursive::ring_challenge_config, + ) + .unwrap(); + + assert!(planned.estimate.selected_offload_edges > 0); + assert_eq!( + planned + .schedule + .root + .params + .final_group + .commitment + .role_dims(), + CommitmentRingDims { + inner: 256, + outer: 64, + opening: 64, + } + ); + assert_eq!( + planned + .schedule + .root + .params + .final_group + .commitment + .open_commit_matrix + .input_width(), + 176_472, + "root D width projects the main group once and then adds both frozen precommit segments" + ); + assert_eq!( + planned.schedule.recursive_folds[0] + .params + .witness + .role_dims(), + CommitmentRingDims { + inner: 256, + outer: 64, + opening: 64, + } + ); + assert_eq!( + planned.schedule.recursive_folds[1] + .params + .witness + .role_dims(), + CommitmentRingDims::uniform(64) + ); + let mut previous = planned + .schedule + .root + .params + .final_group + .commitment + .role_dims(); + for fold in &planned.schedule.recursive_folds { + let current = fold.params.witness.role_dims(); + assert!(current.d_a() <= previous.d_a()); + assert!(current.d_b() <= previous.d_b()); + assert!(current.d_d() <= previous.d_d()); + if let Some(prefix) = &fold.params.witness.setup_prefix { + assert_eq!( + prefix + .commitment_params + .layout + .inner_commit_matrix + .ring_dimension(), + current.d_a() + ); + assert_eq!( + prefix + .commitment_params + .layout + .outer_commit_matrix + .ring_dimension(), + current.d_b() + ); + } + previous = current; + } +} diff --git a/crates/akita-planner/src/test/suffix_dp.rs b/crates/akita-planner/src/test/suffix_dp.rs index 304be7117..caebfe2a4 100644 --- a/crates/akita-planner/src/test/suffix_dp.rs +++ b/crates/akita-planner/src/test/suffix_dp.rs @@ -1,4 +1,51 @@ -use super::offloaded_witness_contracts; +use super::{dominates_mixed_score, offloaded_witness_contracts}; +use crate::schedule_params::MixedScore; + +#[test] +fn mixed_frontier_keeps_lower_payload_child_until_parent_masks_setup() { + let lower_setup = MixedScore { + setup_field_elements: 10, + proof_bytes: 20, + }; + let lower_payload = MixedScore { + setup_field_elements: 15, + proof_bytes: 10, + }; + assert!(!dominates_mixed_score(lower_setup, lower_payload)); + assert!(!dominates_mixed_score(lower_payload, lower_setup)); + + let parent_setup = 20; + let lower_setup_complete = MixedScore { + setup_field_elements: parent_setup.max(lower_setup.setup_field_elements), + proof_bytes: lower_setup.proof_bytes, + }; + let lower_payload_complete = MixedScore { + setup_field_elements: parent_setup.max(lower_payload.setup_field_elements), + proof_bytes: lower_payload.proof_bytes, + }; + assert!(lower_payload_complete < lower_setup_complete); +} + +#[test] +fn mixed_frontier_keeps_equal_payload_alternatives_for_descriptor_ties() { + let lower_setup = MixedScore { + setup_field_elements: 10, + proof_bytes: 20, + }; + let higher_setup = MixedScore { + setup_field_elements: 15, + proof_bytes: 20, + }; + + assert!(!dominates_mixed_score(lower_setup, higher_setup)); + assert!(!dominates_mixed_score(higher_setup, lower_setup)); + + let parent_setup = 20; + assert_eq!( + parent_setup.max(lower_setup.setup_field_elements), + parent_setup.max(higher_setup.setup_field_elements) + ); +} #[test] fn offloaded_contraction_accepts_exact_threefold_boundary() { diff --git a/crates/akita-planner/src/test/unpruned_search.rs b/crates/akita-planner/src/test/unpruned_search.rs index 6d79bfeb4..79a1e7518 100644 --- a/crates/akita-planner/src/test/unpruned_search.rs +++ b/crates/akita-planner/src/test/unpruned_search.rs @@ -1,4 +1,5 @@ use super::*; +use akita_schedules::planner_support::MAX_RECURSION_DEPTH; struct UnprunedCtx<'a> { policy: &'a PlannerPolicy, @@ -43,8 +44,8 @@ fn enumerate_suffixes( for log_basis in min_log_basis.max(current_log_basis)..=max_log_basis { for candidate_dimensions in dimensions.candidates() { - let suffix_dimensions = CommitmentRingDims::uniform(MIXED_SEARCH_SUFFIX_RING_DIMENSION); - if level >= MIXED_SEARCH_FOLD_LEVELS { + let suffix_dimensions = CommitmentRingDims::uniform(ADAPTIVE_SUFFIX_RING_DIMENSION); + if level >= akita_schedules::ADAPTIVE_SEARCH_LEVELS { if *candidate_dimensions != suffix_dimensions { continue; } @@ -66,12 +67,14 @@ fn enumerate_suffixes( continue; }; for &payload_mode in payload_phase.candidate_modes(level, false) { - let candidates = if level < MIXED_SEARCH_FOLD_LEVELS { + let candidates = if level < akita_schedules::ADAPTIVE_SEARCH_LEVELS { derive_candidate_level_params_all_splits( policy, payload_mode, &ring_challenge, - *candidate_dimensions, + akita_schedules::planner_support::RingDimensionCandidate::Fixed( + *candidate_dimensions, + ), input_witness_len, log_basis, level, @@ -82,7 +85,9 @@ fn enumerate_suffixes( policy, payload_mode, &ring_challenge, - *candidate_dimensions, + akita_schedules::planner_support::RingDimensionCandidate::Fixed( + *candidate_dimensions, + ), input_witness_len, log_basis, level, @@ -94,7 +99,7 @@ fn enumerate_suffixes( for (params, output_witness_len) in candidates { let terminal_candidate = if dimensions.candidates().len() == 1 - || level >= MIXED_SEARCH_FOLD_LEVELS + || level >= akita_schedules::ADAPTIVE_SEARCH_LEVELS { suffix_dp::try_terminal_direct_suffix_cost( input_witness_len, @@ -136,8 +141,8 @@ fn enumerate_suffixes( }); } - let child_ceiling = if level + 1 >= MIXED_SEARCH_FOLD_LEVELS { - CommitmentRingDims::uniform(MIXED_SEARCH_SUFFIX_RING_DIMENSION) + let child_ceiling = if level + 1 >= akita_schedules::ADAPTIVE_SEARCH_LEVELS { + CommitmentRingDims::uniform(ADAPTIVE_SUFFIX_RING_DIMENSION) } else { params.role_dims() }; @@ -214,7 +219,7 @@ pub(super) fn find_schedule( ring_challenge_config: impl Fn(usize) -> Result, ) -> Result { key.validate()?; - validate_policy(policy)?; + akita_schedules::planner_support::validate_policy(policy)?; let field_bits = policy.decomposition.field_bits(); let input_witness_len = 1usize.checked_shl(key.num_vars() as u32).ok_or_else(|| { @@ -246,7 +251,9 @@ pub(super) fn find_schedule( honest_fold_policy, &[], policy, - *root_dimensions, + akita_schedules::planner_support::RingDimensionCandidate::Fixed( + *root_dimensions, + ), &ring_challenge, &ring_challenge_config, input_witness_len, diff --git a/crates/akita-prover/src/compute/cpu.rs b/crates/akita-prover/src/compute/cpu.rs index e4e328943..8584f8cc9 100644 --- a/crates/akita-prover/src/compute/cpu.rs +++ b/crates/akita-prover/src/compute/cpu.rs @@ -236,17 +236,17 @@ impl CpuPreparedSetup { self.compression_ntt.cache_bytes() } - /// CRT/NTT profile and universal i8 capacity metadata for ring degree `D`. - pub fn shared_ntt_profile(&self) -> Result { + /// CRT/NTT profile and universal i8 capacity metadata for `ring_d`. + pub fn shared_ntt_profile(&self, ring_d: usize) -> Result { self.ntt_i8_capacity_by_ring_d .lock() .map_err(|_| AkitaError::InvalidSetup("NTT profile lock poisoned".into()))? - .get(&D) + .get(&ring_d) .copied() .map(Into::into) .ok_or_else(|| { AkitaError::InvalidSetup(format!( - "prepared setup has no CRT/i8 capacity profile for ring_d={D}" + "prepared setup has no CRT/i8 capacity profile for ring_d={ring_d}" )) }) } @@ -968,7 +968,7 @@ mod tests { CpuBackend .digit_rows::(&prepared, 1, &[[1i8; D]], 2) .expect("build exact NTT prefix"); - let profile = prepared.shared_ntt_profile::().expect("profile"); + let profile = prepared.shared_ntt_profile(D).expect("profile"); assert_eq!(profile.profile_id, "Q64/3xi32"); assert_eq!(profile.num_primes, 3); diff --git a/crates/akita-prover/src/compute/requirements.rs b/crates/akita-prover/src/compute/requirements.rs index 5125df711..6375a3e89 100644 --- a/crates/akita-prover/src/compute/requirements.rs +++ b/crates/akita-prover/src/compute/requirements.rs @@ -358,7 +358,7 @@ mod tests { #[test] #[cfg(feature = "schedules-default")] fn generated_schedule_excludes_prior_root_commitment() { - let schedule = fp128::D64OneHot::runtime_schedule(AkitaScheduleLookupKey::single( + let schedule = fp128::OneHot::runtime_schedule(AkitaScheduleLookupKey::single( PolynomialGroupLayout::singleton(32), )) .expect("generated schedule"); diff --git a/crates/akita-prover/src/protocol/core/tests.rs b/crates/akita-prover/src/protocol/core/tests.rs index 7c72b84fb..7b216f07b 100644 --- a/crates/akita-prover/src/protocol/core/tests.rs +++ b/crates/akita-prover/src/protocol/core/tests.rs @@ -1,7 +1,7 @@ use super::*; use crate::RecursiveWitnessFlat; use akita_config::{ - proof_optimized::fp128::D64OneHot, CommitmentConfig, PrecommittedCommitmentConfig, + proof_optimized::fp128::OneHot, CommitmentConfig, PrecommittedCommitmentConfig, }; use akita_field::{Fp32, FpExt2, TwoNr}; use akita_transcript::AkitaTranscript; @@ -110,11 +110,11 @@ fn proof_schedule_from_layout_includes_entire_batch() { assert_eq!(batch.num_groups(), 3); let pre_layout = OpeningClaimsLayout::new(16, 1).expect("precommit layout"); let pre_params = - PrecommittedCommitmentConfig::::get_params_for_batched_commitment(&pre_layout) + PrecommittedCommitmentConfig::::get_params_for_batched_commitment(&pre_layout) .expect("precommit params"); let precommitted = CommittedGroupProfile::from_params(PolynomialGroupLayout::new(16, 1), &pre_params); - let schedule = D64OneHot::runtime_schedule(AkitaScheduleLookupKey { + let schedule = OneHot::runtime_schedule(AkitaScheduleLookupKey { final_group: PolynomialGroupLayout::new(32, 2), precommitteds: vec![precommitted, precommitted], }) diff --git a/crates/akita-prover/src/protocol/sumcheck/relation_range_image/evaluation_trace/tests.rs b/crates/akita-prover/src/protocol/sumcheck/relation_range_image/evaluation_trace/tests.rs index a66df867b..6579df8b6 100644 --- a/crates/akita-prover/src/protocol/sumcheck/relation_range_image/evaluation_trace/tests.rs +++ b/crates/akita-prover/src/protocol/sumcheck/relation_range_image/evaluation_trace/tests.rs @@ -10,7 +10,7 @@ use akita_types::{ RingMultiplierOpeningPoint, WitnessLayout, }; -type Cfg = fp128::D128Dense; +type Cfg = fp128::Dense; type F = fp128::Field; const D: usize = Cfg::D; const NUM_VARIABLES: usize = 16; @@ -90,6 +90,7 @@ where let live_len = witness_layout.live_coeff_len(); let relation_address_geometry = RelationAddressGeometry::new(level_params.role_dims(), D, live_len).unwrap(); + let common_coefficient_count = relation_address_geometry.relation_coefficient_block_len(); let plan = RelationRangeImagePlan::new( relation_address_geometry, DigitRangePlan::new(1usize << level_params.log_basis_open).unwrap(), @@ -138,7 +139,11 @@ where let mut padded_expected_table = expected_table.clone(); padded_expected_table.resize(1usize << point.len(), E::zero()); - for coeff_count in [D, D / 2, D / 4] { + for coeff_count in [ + common_coefficient_count, + common_coefficient_count / 2, + common_coefficient_count / 4, + ] { let prepared = PreparedProverEvaluationTrace::new(&semantic_trace, coeff_count, output_scale).unwrap(); assert_eq!(prepared.materialize_dense(), expected_table,); @@ -148,7 +153,7 @@ where multilinear_eval(&padded_expected_table, &point).unwrap() ); } - for malformed_common_count in [0, 3, D * 2] { + for malformed_common_count in [0, 3, common_coefficient_count * 2] { assert!(PreparedProverEvaluationTrace::new( &semantic_trace, malformed_common_count, diff --git a/crates/akita-prover/tests/dispatch_dim.rs b/crates/akita-prover/tests/dispatch_dim.rs index 78b3fc051..05a5420a7 100644 --- a/crates/akita-prover/tests/dispatch_dim.rs +++ b/crates/akita-prover/tests/dispatch_dim.rs @@ -41,8 +41,14 @@ fn accepts_real_fp64_d128_schedule() { } #[test] -fn accepts_real_fp128_d128_schedule() { - let schedule = schedule::(18); - validate_schedule_ring_dims(&schedule).expect("D128 schedule"); - assert_schedule_geometry(&schedule, 128); +fn accepts_real_fp128_adaptive_schedule() { + let schedule = schedule::(16); + validate_schedule_ring_dims(&schedule).expect("adaptive schedule"); + assert!( + schedule + .recursive_folds + .iter() + .any(|fold| fold.params.witness.d_a() + != schedule.root.params.final_group.commitment.d_a()) + ); } diff --git a/crates/akita-prover/tests/orchestration_dim.rs b/crates/akita-prover/tests/orchestration_dim.rs index 47b1ecb20..eb671288b 100644 --- a/crates/akita-prover/tests/orchestration_dim.rs +++ b/crates/akita-prover/tests/orchestration_dim.rs @@ -41,12 +41,12 @@ fn batched_selection_preserves_typed_schedule_topology() { #[test] fn role_dispatch_rejects_wrong_inner_dimension() { - let schedule = fp128::D128Dense::runtime_schedule(AkitaScheduleLookupKey::single( + let schedule = fp128::Dense::runtime_schedule(AkitaScheduleLookupKey::single( PolynomialGroupLayout::singleton(16), )) .expect("runtime schedule"); let dims = schedule.root.params.final_group.commitment.role_dims(); - assert!(validate_role_dispatch::<64>(dims, RingRole::Inner).is_err()); + assert!(validate_role_dispatch::<128>(dims, RingRole::Inner).is_err()); } #[test] @@ -57,9 +57,9 @@ fn real_presets_validate_against_setup_ring_dimension() { .expect("fp64 schedule"); validate_schedule_ring_dims(&fp64_schedule).expect("D128 schedule envelope"); - let fp128_schedule = fp128::D64Dense::runtime_schedule(AkitaScheduleLookupKey::single( + let fp128_schedule = fp128::Dense::runtime_schedule(AkitaScheduleLookupKey::single( PolynomialGroupLayout::singleton(14), )) .expect("fp128 schedule"); - validate_schedule_ring_dims(&fp128_schedule).expect("D64 schedule envelope"); + validate_schedule_ring_dims(&fp128_schedule).expect("adaptive schedule envelope"); } diff --git a/crates/akita-schedules/Cargo.toml b/crates/akita-schedules/Cargo.toml index eef51e17f..ac6527ef4 100644 --- a/crates/akita-schedules/Cargo.toml +++ b/crates/akita-schedules/Cargo.toml @@ -19,38 +19,30 @@ readme = "../../README.md" default = [] all-schedules = [ "schedules-default", - "fp128-mixed-dim-onehot", - "fp128-d64-onehot-recursive", - "fp128-d64-onehot-recursive-multi-chunk-w8r2", - "fp128-d64-onehot-multi-chunk", - "fp128-d64-onehot-multi-chunk-w2r2", - "fp128-d64-onehot-multi-chunk-w4r2", - "fp128-d64-dense-multi-chunk", + "fp128-onehot-recursive", + "fp128-onehot-recursive-multi-chunk-w8r2", + "fp128-onehot-multi-chunk", + "fp128-onehot-multi-chunk-w2r2", + "fp128-onehot-multi-chunk-w4r2", + "fp128-dense-multi-chunk", ] schedules-default = [ - "fp128-d64-onehot", - "fp128-d64-dense", - "fp128-d128-onehot", - "fp128-d128-dense", - "fp128-d256-onehot", + "fp128-onehot", + "fp128-dense", "fp32-d128-onehot", "fp32-d256-onehot", "fp64-d128-dense", "fp64-d128-onehot", "fp64-d256-onehot", ] -fp128-d64-onehot = [] -fp128-mixed-dim-onehot = [] -fp128-d64-onehot-recursive = [] -fp128-d64-onehot-recursive-multi-chunk-w8r2 = [] -fp128-d64-dense = [] -fp128-d128-onehot = [] -fp128-d128-dense = [] -fp128-d256-onehot = [] -fp128-d64-onehot-multi-chunk = [] -fp128-d64-onehot-multi-chunk-w2r2 = [] -fp128-d64-onehot-multi-chunk-w4r2 = [] -fp128-d64-dense-multi-chunk = [] +fp128-onehot = [] +fp128-dense = [] +fp128-onehot-recursive = [] +fp128-onehot-recursive-multi-chunk-w8r2 = [] +fp128-onehot-multi-chunk = [] +fp128-onehot-multi-chunk-w2r2 = [] +fp128-onehot-multi-chunk-w4r2 = [] +fp128-dense-multi-chunk = [] fp32-d128-onehot = [] fp32-d256-onehot = [] diff --git a/crates/akita-schedules/src/candidate.rs b/crates/akita-schedules/src/candidate.rs index 94b472a48..3670bb310 100644 --- a/crates/akita-schedules/src/candidate.rs +++ b/crates/akita-schedules/src/candidate.rs @@ -1,8 +1,113 @@ //! Shared candidate-construction helpers. use crate::runtime::PlannerPolicy; -use akita_types::sis::{projected_role_ring_count, rounded_up_collision_inf_norm, SisTableKey}; -use akita_types::SisMatrixRole; +use akita_field::AkitaError; +use akita_types::sis::{ + min_secure_rank, projected_role_ring_count, rounded_up_collision_inf_norm, SisTableKey, +}; +use akita_types::{CommitmentRingDims, SisMatrixRole}; + +/// Exact or adaptively derived dimensions for one planner candidate. +#[derive(Clone, Copy, Debug)] +pub enum RingDimensionCandidate<'a> { + Fixed(CommitmentRingDims), + Adaptive { + inner: usize, + outer_dimensions: &'a [usize], + opening_dimensions: &'a [usize], + ceiling: CommitmentRingDims, + }, +} + +impl RingDimensionCandidate<'_> { + pub fn inner(self) -> usize { + match self { + Self::Fixed(dimensions) => dimensions.d_a(), + Self::Adaptive { inner, .. } => inner, + } + } + + pub fn validate(self) -> Result<(), AkitaError> { + match self { + Self::Fixed(dimensions) => dimensions.validate_role_projection(), + Self::Adaptive { inner, ceiling, .. } => { + ceiling.validate_role_projection()?; + if inner == 0 || !inner.is_power_of_two() || inner > ceiling.d_a() { + return Err(AkitaError::InvalidSetup(format!( + "adaptive A dimension D{inner} is invalid under D{} ceiling", + ceiling.d_a() + ))); + } + Ok(()) + } + } + } + + pub fn collision_role_price( + self, + policy: &PlannerPolicy, + role: SisMatrixRole, + native_width: usize, + log_basis: u32, + ) -> Option<(SisTableKey, usize)> { + let source_dimension = self.inner(); + match self { + Self::Fixed(dimensions) => { + let role_dimension = match role { + SisMatrixRole::Outer => dimensions.d_b(), + SisMatrixRole::Open => dimensions.d_d(), + SisMatrixRole::Inner => return None, + }; + projected_collision_role_price( + policy, + role, + source_dimension, + role_dimension, + native_width, + log_basis, + ) + } + Self::Adaptive { + outer_dimensions, + opening_dimensions, + ceiling, + .. + } => { + let (dimensions, role_ceiling) = match role { + SisMatrixRole::Outer => (outer_dimensions, ceiling.d_b()), + SisMatrixRole::Open => (opening_dimensions, ceiling.d_d()), + SisMatrixRole::Inner => return None, + }; + let mut best = None; + for &role_dimension in dimensions { + if role_dimension > source_dimension || role_dimension > role_ceiling { + continue; + } + let Some((key, width)) = projected_collision_role_price( + policy, + role, + source_dimension, + role_dimension, + native_width, + log_basis, + ) else { + continue; + }; + let rank = min_secure_rank(key, u64::try_from(width).ok()?)?; + if best.as_ref().is_none_or(|(best_rank, best_d, _, _)| { + (rank, role_dimension) < (*best_rank, *best_d) + }) { + best = Some((rank, role_dimension, key, width)); + } + if rank == 1 { + break; + } + } + best.map(|(_, _, key, width)| (key, width)) + } + } + } +} /// Construct the canonical SIS-table key for one role and ring dimension. pub fn sis_key_at_dimension( @@ -26,14 +131,14 @@ pub fn sis_key_at_dimension( pub fn projected_collision_role_price( policy: &PlannerPolicy, role: SisMatrixRole, - carrier_dimension: usize, + source_dimension: usize, role_dimension: usize, native_width: usize, log_basis: u32, ) -> Option<(SisTableKey, usize)> { if role == SisMatrixRole::Inner || role_dimension == 0 - || !carrier_dimension.is_multiple_of(role_dimension) + || !source_dimension.is_multiple_of(role_dimension) { return None; } @@ -44,8 +149,7 @@ pub fn projected_collision_role_price( role_dimension, log_basis, )?; - let physical_width = - projected_role_ring_count(carrier_dimension, role_dimension, native_width)?; + let physical_width = projected_role_ring_count(source_dimension, role_dimension, native_width)?; Some(( sis_key_at_dimension(policy, role, role_dimension, coeff_linf_bound), physical_width, diff --git a/crates/akita-schedules/src/catalog_identity.rs b/crates/akita-schedules/src/catalog_identity.rs index 1e35a31fd..8a42b72af 100644 --- a/crates/akita-schedules/src/catalog_identity.rs +++ b/crates/akita-schedules/src/catalog_identity.rs @@ -19,7 +19,7 @@ use crate::generated::{ GeneratedFoldScheduleEntry, GeneratedOpenCommitMatrix, GeneratedScheduleCatalogIdentity, GeneratedScheduleTable, GeneratedWitnessPartition, }; -use crate::PlannerPolicy; +use crate::{PlannerPolicy, RingDimensionScheduleMode}; static VALIDATED_CATALOGS: LazyLock>> = LazyLock::new(|| Mutex::new(HashSet::new())); @@ -48,7 +48,7 @@ pub fn policy_digest(policy: &PlannerPolicy) -> [u8; 32] { h.write_bytes(&policy.sis_table_digest.0); h.write_u64(policy.uniform_ring_dimension as u64); h.write_u64(policy.setup_prefix_inner_ring_dimension as u64); - write_ring_dimension_candidates(&mut h, policy.ring_dimension_candidates); + write_ring_dimension_schedule_mode(&mut h, policy.ring_dimension_schedule_mode); write_decomposition(&mut h, policy.decomposition); h.write_u64(u64::from(policy.ring_subfield_norm_bound)); h.write_u64(policy.claim_ext_degree as u64); @@ -96,7 +96,7 @@ pub fn identity_digest(identity: &GeneratedScheduleCatalogIdentity) -> [u8; 32] for &d in identity.ring_dimensions { h.write_u64(d as u64); } - write_ring_dimension_candidates(&mut h, identity.ring_dimension_candidates); + write_ring_dimension_schedule_mode(&mut h, identity.ring_dimension_schedule_mode); h.write_u64(identity.ring_challenge_config_digest); h.write_u64(identity.key_count as u64); h.write_u64(identity.key_digest); @@ -140,7 +140,7 @@ struct CatalogIdentityExpectation { witness_chunk: akita_types::ChunkedWitnessCfg, recursive_setup_planning: bool, - ring_dimension_candidates: Vec, + ring_dimension_schedule_mode: RingDimensionScheduleMode, ring_dimensions: Vec, ring_challenge_config_digest: u64, key_count: usize, @@ -170,7 +170,7 @@ impl CatalogIdentityExpectation { witness_chunk: identity.witness_chunk, recursive_setup_planning: identity.recursive_setup_planning, - ring_dimension_candidates: identity.ring_dimension_candidates.to_vec(), + ring_dimension_schedule_mode: identity.ring_dimension_schedule_mode, ring_dimensions: identity.ring_dimensions.to_vec(), ring_challenge_config_digest: identity.ring_challenge_config_digest, key_count: identity.key_count, @@ -183,22 +183,15 @@ fn intern_ring_dimensions(dimensions: Vec) -> &'static [usize] { Box::leak(dimensions.into_boxed_slice()) } -fn intern_ring_dimension_candidates( - candidates: Vec, -) -> &'static [CommitmentRingDims] { - Box::leak(candidates.into_boxed_slice()) -} - fn catalog_identity_expectation( family_name: &'static str, policy: &PlannerPolicy, entries: &[GeneratedFoldScheduleEntry], ring_challenge_config: impl Fn(usize) -> Result, ) -> Result { - validate_entry_candidate_dimensions(entries, policy.ring_dimension_candidates)?; - let ring_dimension_candidates = policy.ring_dimension_candidates.to_vec(); + validate_entry_dimensions(entries, policy.ring_dimension_schedule_mode)?; let ring_dimensions = collect_ring_dimensions(entries); - let challenge_ring_dimensions = candidate_a_dimensions(policy.ring_dimension_candidates); + let challenge_ring_dimensions = challenge_a_dimensions(policy.ring_dimension_schedule_mode); let ring_challenge_config_digest = ring_challenge_config_digest(&challenge_ring_dimensions, &ring_challenge_config)?; Ok(CatalogIdentityExpectation { @@ -221,7 +214,7 @@ fn catalog_identity_expectation( witness_chunk: policy.witness_chunk, recursive_setup_planning: policy.recursive_setup_planning, - ring_dimension_candidates, + ring_dimension_schedule_mode: policy.ring_dimension_schedule_mode, ring_dimensions, ring_challenge_config_digest, key_count: entries.len(), @@ -259,9 +252,7 @@ pub fn expected_catalog_identity( witness_chunk: expected.witness_chunk, recursive_setup_planning: expected.recursive_setup_planning, - ring_dimension_candidates: intern_ring_dimension_candidates( - expected.ring_dimension_candidates, - ), + ring_dimension_schedule_mode: expected.ring_dimension_schedule_mode, ring_dimensions: intern_ring_dimensions(expected.ring_dimensions), ring_challenge_config_digest: expected.ring_challenge_config_digest, key_count: expected.key_count, @@ -325,7 +316,7 @@ fn verify_ring_challenge_config_digest_on_cache_hit( identity: &GeneratedScheduleCatalogIdentity, ring_challenge_config: impl Fn(usize) -> Result, ) -> Result<(), AkitaError> { - let challenge_ring_dimensions = candidate_a_dimensions(identity.ring_dimension_candidates); + let challenge_ring_dimensions = challenge_a_dimensions(identity.ring_dimension_schedule_mode); let recomputed = ring_challenge_config_digest(&challenge_ring_dimensions, ring_challenge_config)?; if recomputed != identity.ring_challenge_config_digest { @@ -387,48 +378,54 @@ fn collect_ring_dimensions(entries: &[GeneratedFoldScheduleEntry]) -> Vec dims } -fn candidate_a_dimensions(candidates: &[CommitmentRingDims]) -> Vec { - let mut dimensions = candidates.iter().map(|dims| dims.d_a()).collect::>(); - dimensions.sort_unstable(); - dimensions.dedup(); - dimensions +fn challenge_a_dimensions(mode: RingDimensionScheduleMode) -> Vec { + match mode { + RingDimensionScheduleMode::UniformDimension { ring_dimension } => vec![ring_dimension], + RingDimensionScheduleMode::AdaptiveDimension { + potential_a_dimensions, + .. + } => potential_a_dimensions.to_vec(), + } } -fn validate_entry_candidate_dimensions( +fn validate_entry_dimensions( entries: &[GeneratedFoldScheduleEntry], - candidates: &[CommitmentRingDims], + mode: RingDimensionScheduleMode, ) -> Result<(), AkitaError> { - let admitted = |group: GeneratedCommittedGroup, opening: u32| { - let dims = CommitmentRingDims { - inner: group.inner_commit_matrix.ring_dimension as usize, - outer: group.outer_commit_matrix.ring_dimension as usize, - opening: opening as usize, - }; - candidates.contains(&dims).then_some(dims) + let dimensions = |group: GeneratedCommittedGroup, opening: u32| CommitmentRingDims { + inner: group.inner_commit_matrix.ring_dimension as usize, + outer: group.outer_commit_matrix.ring_dimension as usize, + opening: opening as usize, }; for entry in entries { - admitted( + let root = dimensions( entry.root.final_group.commitment, entry.root.open_commit_matrix.ring_dimension, - ) - .ok_or_else(|| { - AkitaError::InvalidSetup(format!( - "generated root dimensions are outside the catalog candidate domain for key {:?}", - entry.root.final_group.layout - )) - })?; - for fold in entry.recursive_folds { - admitted(fold.witness, fold.open_commit_matrix.ring_dimension).ok_or_else(|| { - AkitaError::InvalidSetup(format!( - "generated recursive dimensions are outside the catalog candidate domain for key {:?}", - entry.root.final_group.layout - )) - })?; + ); + validate_level_dimensions(mode, 0, root, None, entry.root.final_group.layout)?; + let mut previous = root; + for (index, fold) in entry.recursive_folds.iter().enumerate() { + let current = dimensions(fold.witness, fold.open_commit_matrix.ring_dimension); + validate_level_dimensions( + mode, + index + 1, + current, + Some(previous), + entry.root.final_group.layout, + )?; + previous = current; } let terminal_d = entry.terminal.inner_commit_matrix.ring_dimension as usize; - if !candidates.iter().any(|dims| dims.d_a() == terminal_d) { + let expected_terminal = match mode { + RingDimensionScheduleMode::UniformDimension { ring_dimension } => ring_dimension, + RingDimensionScheduleMode::AdaptiveDimension { + uniform_suffix_dimension, + .. + } => uniform_suffix_dimension, + }; + if terminal_d != expected_terminal { return Err(AkitaError::InvalidSetup(format!( - "generated terminal dimension D{terminal_d} is outside the catalog candidate domain for key {:?}", + "generated terminal D{terminal_d} is not policy suffix D{expected_terminal} for key {:?}", entry.root.final_group.layout ))); } @@ -436,6 +433,46 @@ fn validate_entry_candidate_dimensions( Ok(()) } +fn validate_level_dimensions( + mode: RingDimensionScheduleMode, + level: usize, + dimensions: CommitmentRingDims, + previous: Option, + key: PolynomialGroupLayout, +) -> Result<(), AkitaError> { + let admitted = match mode { + RingDimensionScheduleMode::UniformDimension { ring_dimension } => { + dimensions == CommitmentRingDims::uniform(ring_dimension) + } + RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + } => { + if level < num_search_levels { + potential_a_dimensions.contains(&dimensions.d_a()) + && potential_b_dimensions.contains(&dimensions.d_b()) + && potential_d_dimensions.contains(&dimensions.d_d()) + && previous.is_none_or(|ceiling| { + dimensions.d_a() <= ceiling.d_a() + && dimensions.d_b() <= ceiling.d_b() + && dimensions.d_d() <= ceiling.d_d() + }) + } else { + dimensions == CommitmentRingDims::uniform(uniform_suffix_dimension) + } + } + }; + if !admitted { + return Err(AkitaError::InvalidSetup(format!( + "generated dimensions {dimensions:?} at level {level} are outside policy for key {key:?}" + ))); + } + Ok(()) +} + fn collect_group_ring_dimensions(group: GeneratedCommittedGroup, dims: &mut Vec) { push_unique(dims, group.inner_commit_matrix.ring_dimension as usize); push_unique(dims, group.outer_commit_matrix.ring_dimension as usize); @@ -546,12 +583,33 @@ pub fn ring_challenge_config_digest( Ok(h.finish()) } -fn write_ring_dimension_candidates(h: &mut Fnv64, candidates: &[CommitmentRingDims]) { - h.write_u64(candidates.len() as u64); - for dims in candidates { - h.write_u64(dims.d_a() as u64); - h.write_u64(dims.d_b() as u64); - h.write_u64(dims.d_d() as u64); +fn write_ring_dimension_schedule_mode(h: &mut Fnv64, mode: RingDimensionScheduleMode) { + match mode { + RingDimensionScheduleMode::UniformDimension { ring_dimension } => { + h.write_u64(0); + h.write_u64(ring_dimension as u64); + } + RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + } => { + h.write_u64(1); + h.write_u64(num_search_levels as u64); + h.write_u64(uniform_suffix_dimension as u64); + for dimensions in [ + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + ] { + h.write_u64(dimensions.len() as u64); + for &dimension in dimensions { + h.write_u64(dimension as u64); + } + } + } } } diff --git a/crates/akita-schedules/src/generated/expand.rs b/crates/akita-schedules/src/generated/expand.rs index 6738f1e08..fee295761 100644 --- a/crates/akita-schedules/src/generated/expand.rs +++ b/crates/akita-schedules/src/generated/expand.rs @@ -648,13 +648,13 @@ impl GeneratedCommittedGroup { precommitted_d_width: usize, open_commit_matrix: GeneratedOpenCommitMatrix, ) -> Result { - let ring_d = self.inner_commit_matrix.ring_dimension as usize; - if ring_d == 0 || ring_d != policy.uniform_ring_dimension { - return Err(AkitaError::InvalidSetup(format!( - "generated multi-group root ring dimension {ring_d} does not match uniform policy D={}", - policy.uniform_ring_dimension - ))); - } + let dimensions = CommitmentRingDims { + inner: self.inner_commit_matrix.ring_dimension as usize, + outer: self.outer_commit_matrix.ring_dimension as usize, + opening: open_commit_matrix.ring_dimension as usize, + }; + validate_role_dims(dimensions)?; + let ring_d = dimensions.d_a(); if precommitted_groups.is_empty() { return Err(AkitaError::InvalidSetup( "generated multi-group root requires precommitted groups".to_string(), @@ -740,17 +740,23 @@ impl GeneratedCommittedGroup { sis_policy, sis_modulus_profile, akita_types::SisMatrixRole::Outer, - ring_d, + dimensions.d_b(), log_basis_outer, ) .ok_or_else(|| no_layout("B"))?; - let outer_width = + let native_outer_width = decomposed_t_ring_count(n_a, num_digits_outer, num_live_blocks, main_num_polys) .ok_or_else(|| no_layout("B"))?; + let outer_width = + projected_role_ring_count(dimensions.d_a(), dimensions.d_b(), native_outer_width) + .ok_or_else(|| no_layout("B"))?; - let main_d_width = + let native_main_d_width = decomposed_w_ring_count(num_digits_open_val, num_live_blocks, main_num_polys) .ok_or_else(|| no_layout("D"))?; + let main_d_width = + projected_role_ring_count(dimensions.d_a(), dimensions.d_d(), native_main_d_width) + .ok_or_else(|| no_layout("D"))?; let d_matrix_width = main_d_width .checked_add(precommitted_d_width) .ok_or_else(|| { @@ -761,7 +767,7 @@ impl GeneratedCommittedGroup { sis_policy, sis_modulus_profile, akita_types::SisMatrixRole::Open, - ring_d, + dimensions.d_d(), d_log_basis, ) .ok_or_else(|| no_layout("D"))?; @@ -807,7 +813,7 @@ impl GeneratedCommittedGroup { n_b, outer_width, b_bucket, - ring_d, + dimensions.d_b(), )?, open_commit_matrix: OpenCommitMatrixParams::try_new( sis_policy, @@ -816,7 +822,7 @@ impl GeneratedCommittedGroup { n_d, d_matrix_width, d_bucket, - ring_d, + dimensions.d_d(), )?, num_live_ring_elements_per_claim: num_live_blocks .checked_mul(num_positions_per_block) @@ -954,18 +960,12 @@ mod tests { use std::cell::RefCell; use super::*; - use crate::{PlannerCostModelId, SelectionPolicyId}; + use crate::{PlannerCostModelId, RingDimensionScheduleMode, SelectionPolicyId}; use akita_types::{ - ChunkedWitnessCfg, CommitmentRingDims, SisModulusProfileId, SisSecurityPolicyId, - SisTableDigest, + ChunkedWitnessCfg, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; fn recursive_fp128_policy() -> PlannerPolicy { - static CANDIDATES: [CommitmentRingDims; 1] = [CommitmentRingDims { - inner: 64, - outer: 64, - opening: 64, - }]; PlannerPolicy { cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, selection_policy: SelectionPolicyId::MinFirstDirectSetupThenPayload, @@ -973,7 +973,9 @@ mod tests { min_offloaded_witness_contraction: 3, uniform_ring_dimension: 64, setup_prefix_inner_ring_dimension: 128, - ring_dimension_candidates: &CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { + ring_dimension: 64, + }, decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 1, diff --git a/crates/akita-schedules/src/generated/fp128_d128_dense.rs b/crates/akita-schedules/src/generated/fp128_d128_dense.rs deleted file mode 100644 index 21d1829bc..000000000 --- a/crates/akita-schedules/src/generated/fp128_d128_dense.rs +++ /dev/null @@ -1,159 +0,0 @@ -// Generated by `cargo run --release -p akita-planner --features catalog-gen --bin gen_schedule_tables -- ` -#[allow(unused_imports)] -use super::{ - ChunkedWitnessCfg, CommitmentPayloadMode, CommitmentRingDims, CommittedGroupProfile, - DecompositionParams, GeneratedBlockGeometry, GeneratedCommittedGroup, - GeneratedFoldScheduleEntry, GeneratedInnerCommitMatrix, GeneratedOpenCommitMatrix, - GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, - GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, - GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, -}; - -#[rustfmt::skip] -pub(crate) static FP128_D128_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(13, 1), num_digits_inner: 43, num_digits_fold: 3, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 64, positions_per_block: 8, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2584, positions_per_block: 256, live_blocks: 11 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1645, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1381, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(15, 1), num_digits_inner: 43, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 16, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6067, positions_per_block: 512, live_blocks: 12 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2223, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1513, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 1), num_digits_inner: 43, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 16, live_blocks: 32 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8819, positions_per_block: 1024, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4753, positions_per_block: 512, live_blocks: 10 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2091, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1513, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 2), num_digits_inner: 43, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 32, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 11571, positions_per_block: 1024, live_blocks: 12 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 5140, positions_per_block: 512, live_blocks: 11 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2157, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1513, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(18, 1), num_digits_inner: 43, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2048, positions_per_block: 32, live_blocks: 64 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 17075, positions_per_block: 1024, live_blocks: 17 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 5740, positions_per_block: 512, live_blocks: 12 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2223, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1513, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 2), num_digits_inner: 43, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8192, positions_per_block: 128, live_blocks: 64 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 44595, positions_per_block: 1024, live_blocks: 44 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 12227, positions_per_block: 1024, live_blocks: 12 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 5140, positions_per_block: 512, live_blocks: 11 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2157, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1513, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(24, 1), num_digits_inner: 43, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 131072, positions_per_block: 256, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 132659, positions_per_block: 2048, live_blocks: 65 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 19935, positions_per_block: 1024, live_blocks: 20 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6124, positions_per_block: 512, live_blocks: 12 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2223, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1513, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, -]; - -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 128, outer: 128, opening: 128 }]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[128]; -#[rustfmt::skip] -pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d128_dense", - protocol_epoch: 1, - cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinEstimatedProofPayload, - setup_field_budget: None, - min_offloaded_witness_contraction: 3, - sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, - sis_security_policy: SisSecurityPolicyId::Quantum128BitADPS16, - sis_table_digest: SisTableDigest([0xb4, 0x65, 0x7f, 0x62, 0x90, 0x61, 0x5c, 0xf3, 0x58, 0x55, 0x77, 0xd7, 0xad, 0x51, 0x9f, 0x9d, 0xc5, 0x5d, 0x4b, 0x8d, 0xcc, 0x63, 0x16, 0x11, 0x1b, 0x26, 0x70, 0x42, 0xac, 0x3b, 0x92, 0x94]), - uniform_ring_dimension: 128, - setup_prefix_inner_ring_dimension: 128, - decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 128, log_open_bound: None }, - ring_subfield_norm_bound: 1, - claim_ext_degree: 1, - chal_ext_degree: 1, - basis_range: (3, 6), - witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, - recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, - ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12329058664815196960, - key_count: 7, - key_digest: 1877529539742784118, -}; diff --git a/crates/akita-schedules/src/generated/fp128_d128_dense_precommitted.rs b/crates/akita-schedules/src/generated/fp128_d128_dense_precommitted.rs deleted file mode 100644 index d7c747381..000000000 --- a/crates/akita-schedules/src/generated/fp128_d128_dense_precommitted.rs +++ /dev/null @@ -1,15 +0,0 @@ -// Generated by `cargo run --release -p akita-planner --features catalog-gen --bin gen_schedule_tables -- ` -use super::{ - GeneratedBlockGeometry, GeneratedCommittedGroup, GeneratedInnerCommitMatrix, - GeneratedOuterCommitMatrix, GeneratedPrecommittedProfile, PolynomialGroupLayout, -}; - -#[rustfmt::skip] -pub(crate) static FP128_D128_DENSE_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 16, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_inner: 43, inner_output_rank: 2, inner_coeff_linf_bound: 131071, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 32, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_inner: 43, inner_output_rank: 2, inner_coeff_linf_bound: 131071, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 32, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_inner: 43, inner_output_rank: 2, inner_coeff_linf_bound: 131071, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 16, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_inner: 43, inner_output_rank: 3, inner_coeff_linf_bound: 1048575, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 16, live_blocks: 32 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_inner: 43, inner_output_rank: 3, inner_coeff_linf_bound: 1048575, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 32, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_inner: 43, inner_output_rank: 3, inner_coeff_linf_bound: 1048575, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, -]; diff --git a/crates/akita-schedules/src/generated/fp128_d128_onehot.rs b/crates/akita-schedules/src/generated/fp128_d128_onehot.rs deleted file mode 100644 index 9852f731e..000000000 --- a/crates/akita-schedules/src/generated/fp128_d128_onehot.rs +++ /dev/null @@ -1,155 +0,0 @@ -// Generated by `cargo run --release -p akita-planner --features catalog-gen --bin gen_schedule_tables -- ` -#[allow(unused_imports)] -use super::{ - ChunkedWitnessCfg, CommitmentPayloadMode, CommitmentRingDims, CommittedGroupProfile, - DecompositionParams, GeneratedBlockGeometry, GeneratedCommittedGroup, - GeneratedFoldScheduleEntry, GeneratedInnerCommitMatrix, GeneratedOpenCommitMatrix, - GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, - GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, - GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, -}; - -#[rustfmt::skip] -pub(crate) static FP128_D128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(14, 1), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 8, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1869, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1447, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 1), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 64, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1680, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1381, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 1), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8192, positions_per_block: 512, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3608, positions_per_block: 256, live_blocks: 15 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1909, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1447, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 2), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8192, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4632, positions_per_block: 512, live_blocks: 10 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2091, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1513, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(24, 2), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 131072, positions_per_block: 4096, live_blocks: 32 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16968, positions_per_block: 1024, live_blocks: 17 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 5740, positions_per_block: 512, live_blocks: 12 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2223, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1513, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(28, 1), num_digits_inner: 1, num_digits_fold: 3, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2097152, positions_per_block: 8192, live_blocks: 256 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 58120, positions_per_block: 2048, live_blocks: 29 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 13743, positions_per_block: 1024, live_blocks: 14 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 5356, positions_per_block: 512, live_blocks: 11 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2157, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1513, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 1), num_digits_inner: 1, num_digits_fold: 3, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 33554432, positions_per_block: 32768, live_blocks: 1024 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 274995, positions_per_block: 4096, live_blocks: 68 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 28643, positions_per_block: 1024, live_blocks: 28 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6438, positions_per_block: 512, live_blocks: 13 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2289, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1513, positions_per_block: 256, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1018, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2114, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, -]; - -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 128, outer: 128, opening: 128 }]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[128]; -#[rustfmt::skip] -pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d128_onehot", - protocol_epoch: 1, - cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinEstimatedProofPayload, - setup_field_budget: None, - min_offloaded_witness_contraction: 3, - sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, - sis_security_policy: SisSecurityPolicyId::Quantum128BitADPS16, - sis_table_digest: SisTableDigest([0xb4, 0x65, 0x7f, 0x62, 0x90, 0x61, 0x5c, 0xf3, 0x58, 0x55, 0x77, 0xd7, 0xad, 0x51, 0x9f, 0x9d, 0xc5, 0x5d, 0x4b, 0x8d, 0xcc, 0x63, 0x16, 0x11, 0x1b, 0x26, 0x70, 0x42, 0xac, 0x3b, 0x92, 0x94]), - uniform_ring_dimension: 128, - setup_prefix_inner_ring_dimension: 128, - decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 1, log_open_bound: Some(128) }, - ring_subfield_norm_bound: 1, - claim_ext_degree: 1, - chal_ext_degree: 1, - basis_range: (3, 6), - witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, - recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, - ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12329058664815196960, - key_count: 7, - key_digest: 220662051268621961, -}; diff --git a/crates/akita-schedules/src/generated/fp128_d128_onehot_precommitted.rs b/crates/akita-schedules/src/generated/fp128_d128_onehot_precommitted.rs deleted file mode 100644 index 780cc910b..000000000 --- a/crates/akita-schedules/src/generated/fp128_d128_onehot_precommitted.rs +++ /dev/null @@ -1,15 +0,0 @@ -// Generated by `cargo run --release -p akita-planner --features catalog-gen --bin gen_schedule_tables -- ` -use super::{ - GeneratedBlockGeometry, GeneratedCommittedGroup, GeneratedInnerCommitMatrix, - GeneratedOuterCommitMatrix, GeneratedPrecommittedProfile, PolynomialGroupLayout, -}; - -#[rustfmt::skip] -pub(crate) static FP128_D128_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 64, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 1023, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 64, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 1023, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 256, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 1023, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 256, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, -]; diff --git a/crates/akita-schedules/src/generated/fp128_d256_onehot.rs b/crates/akita-schedules/src/generated/fp128_d256_onehot.rs deleted file mode 100644 index c3329eb27..000000000 --- a/crates/akita-schedules/src/generated/fp128_d256_onehot.rs +++ /dev/null @@ -1,75 +0,0 @@ -// Generated by `cargo run --release -p akita-planner --features catalog-gen --bin gen_schedule_tables -- ` -#[allow(unused_imports)] -use super::{ - ChunkedWitnessCfg, CommitmentPayloadMode, CommitmentRingDims, CommittedGroupProfile, - DecompositionParams, GeneratedBlockGeometry, GeneratedCommittedGroup, - GeneratedFoldScheduleEntry, GeneratedInnerCommitMatrix, GeneratedOpenCommitMatrix, - GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, - GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, - GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, -}; - -#[rustfmt::skip] -pub(crate) static FP128_D256_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(14, 1), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 64, positions_per_block: 8, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 256, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 256, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1157, positions_per_block: 128, live_blocks: 10 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 256, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 256, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1061, positions_per_block: 128, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 256, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 256, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 740, positions_per_block: 128, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2849, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 1), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 32, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 256, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 256, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1205, positions_per_block: 128, live_blocks: 10 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 256, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 256, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1061, positions_per_block: 128, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 256, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 256, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 740, positions_per_block: 128, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 524287, z_admission_linf_cap: 2849, z_rice_low_bits: 9, z_payload_bytes: 53248 }, - }, -]; - -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 256, outer: 256, opening: 256 }]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[256]; -#[rustfmt::skip] -pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d256_onehot", - protocol_epoch: 1, - cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinEstimatedProofPayload, - setup_field_budget: None, - min_offloaded_witness_contraction: 3, - sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, - sis_security_policy: SisSecurityPolicyId::Quantum128BitADPS16, - sis_table_digest: SisTableDigest([0xb4, 0x65, 0x7f, 0x62, 0x90, 0x61, 0x5c, 0xf3, 0x58, 0x55, 0x77, 0xd7, 0xad, 0x51, 0x9f, 0x9d, 0xc5, 0x5d, 0x4b, 0x8d, 0xcc, 0x63, 0x16, 0x11, 0x1b, 0x26, 0x70, 0x42, 0xac, 0x3b, 0x92, 0x94]), - uniform_ring_dimension: 256, - setup_prefix_inner_ring_dimension: 256, - decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 1, log_open_bound: Some(128) }, - ring_subfield_norm_bound: 1, - claim_ext_degree: 1, - chal_ext_degree: 1, - basis_range: (3, 6), - witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, - recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, - ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 3667632896996973001, - key_count: 2, - key_digest: 15697451488274734956, -}; diff --git a/crates/akita-schedules/src/generated/fp128_d256_onehot_precommitted.rs b/crates/akita-schedules/src/generated/fp128_d256_onehot_precommitted.rs deleted file mode 100644 index 5a50c8bba..000000000 --- a/crates/akita-schedules/src/generated/fp128_d256_onehot_precommitted.rs +++ /dev/null @@ -1,15 +0,0 @@ -// Generated by `cargo run --release -p akita-planner --features catalog-gen --bin gen_schedule_tables -- ` -use super::{ - GeneratedBlockGeometry, GeneratedCommittedGroup, GeneratedInnerCommitMatrix, - GeneratedOuterCommitMatrix, GeneratedPrecommittedProfile, PolynomialGroupLayout, -}; - -#[rustfmt::skip] -pub(crate) static FP128_D256_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 64, positions_per_block: 32, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 256, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 1023, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 64, positions_per_block: 32, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 256, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 8191, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 64, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 256, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 1023, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 64, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 256, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 8191, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 256, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 1023, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 256, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 8191, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, -]; diff --git a/crates/akita-schedules/src/generated/fp128_d64_dense.rs b/crates/akita-schedules/src/generated/fp128_dense.rs similarity index 81% rename from crates/akita-schedules/src/generated/fp128_d64_dense.rs rename to crates/akita-schedules/src/generated/fp128_dense.rs index 52a5e51ce..524805ddd 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_dense.rs +++ b/crates/akita-schedules/src/generated/fp128_dense.rs @@ -7,53 +7,53 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] -pub(crate) static FP128_D64_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ +pub(crate) static FP128_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(14, 1), num_digits_inner: 43, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 16, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(14, 1), num_digits_inner: 43, num_digits_fold: 3, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 64, positions_per_block: 8, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7577, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1916, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4013, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 1), num_digits_inner: 43, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 32, live_blocks: 32 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 1), num_digits_inner: 43, num_digits_fold: 3, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 16, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 14457, positions_per_block: 1024, live_blocks: 15 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6552, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3636, positions_per_block: 256, live_blocks: 15 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7576, positions_per_block: 512, live_blocks: 15 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4084, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 2), num_digits_inner: 43, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 32, live_blocks: 32 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 2), num_digits_inner: 43, num_digits_fold: 3, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 32, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22713, positions_per_block: 1024, live_blocks: 23 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22799, positions_per_block: 1024, live_blocks: 23 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8088, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, @@ -63,15 +63,15 @@ pub(crate) static FP128_D64_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(17, 4), num_digits_inner: 43, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2048, positions_per_block: 64, live_blocks: 32 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 64, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 44729, positions_per_block: 2048, live_blocks: 22 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 14565, positions_per_block: 1024, live_blocks: 15 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6552, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 44815, positions_per_block: 1024, live_blocks: 44 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16145, positions_per_block: 1024, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6744, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], @@ -80,51 +80,52 @@ pub(crate) static FP128_D64_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(24, 1), num_digits_inner: 43, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 262144, positions_per_block: 1024, live_blocks: 256 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 65536, positions_per_block: 256, live_blocks: 256 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 242873, positions_per_block: 4096, live_blocks: 60 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 24408, positions_per_block: 1024, live_blocks: 24 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8014, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 77295, positions_per_block: 1024, live_blocks: 76 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 56555, positions_per_block: 2048, live_blocks: 28 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16113, positions_per_block: 1024, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6744, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(28, 1), num_digits_inner: 43, num_digits_fold: 5, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4194304, positions_per_block: 2048, live_blocks: 2048 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1048576, positions_per_block: 1024, live_blocks: 1024 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1145786, positions_per_block: 8192, live_blocks: 140 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 69585, positions_per_block: 2048, live_blocks: 34 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 17661, positions_per_block: 1024, live_blocks: 18 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7128, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 352495, positions_per_block: 4096, live_blocks: 87 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 111383, positions_per_block: 2048, live_blocks: 55 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 23079, positions_per_block: 1024, live_blocks: 23 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8088, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(30, 1), num_digits_inner: 43, num_digits_fold: 5, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16777216, positions_per_block: 4096, live_blocks: 4096 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4194304, positions_per_block: 2048, live_blocks: 2048 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2290618, positions_per_block: 16384, live_blocks: 140 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 102353, positions_per_block: 2048, live_blocks: 50 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 21789, positions_per_block: 1024, live_blocks: 22 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7896, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2819174, positions_per_block: 16384, live_blocks: 173 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 110867, positions_per_block: 2048, live_blocks: 55 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 23079, positions_per_block: 1024, live_blocks: 23 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8088, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], @@ -133,16 +134,16 @@ pub(crate) static FP128_D64_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 1), num_digits_inner: 43, num_digits_fold: 5, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 67108864, positions_per_block: 8192, live_blocks: 8192 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16777216, positions_per_block: 4096, live_blocks: 4096 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, + open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4580282, positions_per_block: 16384, live_blocks: 280 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 138473, positions_per_block: 4096, live_blocks: 34 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 19416, positions_per_block: 1024, live_blocks: 19 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7320, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1409349, positions_per_block: 8192, live_blocks: 173 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 221295, positions_per_block: 4096, live_blocks: 55 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 23448, positions_per_block: 1024, live_blocks: 23 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8088, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], @@ -151,17 +152,17 @@ pub(crate) static FP128_D64_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(44, 1), num_digits_inner: 43, num_digits_fold: 6, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 274877906944, positions_per_block: 524288, live_blocks: 524288 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 68719476736, positions_per_block: 262144, live_blocks: 262144 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, + open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 383255782, positions_per_block: 131072, live_blocks: 2925 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 5, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1662514, positions_per_block: 8192, live_blocks: 203 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 85839, positions_per_block: 2048, live_blocks: 42 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 19725, positions_per_block: 1024, live_blocks: 20 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7512, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 450889150, positions_per_block: 131072, live_blocks: 3441 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 5, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1840018, positions_per_block: 8192, live_blocks: 225 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 91515, positions_per_block: 2048, live_blocks: 45 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 20499, positions_per_block: 1024, live_blocks: 21 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7704, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], @@ -170,16 +171,16 @@ pub(crate) static FP128_D64_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(50, 1), num_digits_inner: 43, num_digits_fold: 6, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 17592186044416, positions_per_block: 33554432, live_blocks: 524288 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4398046511104, positions_per_block: 2097152, live_blocks: 2097152 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, + open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8927577361, positions_per_block: 1048576, live_blocks: 8515 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 5, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8172994, positions_per_block: 32768, live_blocks: 250 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 196269, positions_per_block: 4096, live_blocks: 48 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22104, positions_per_block: 1024, live_blocks: 22 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 901775728, positions_per_block: 131072, live_blocks: 6881 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } }, num_digits_fold: 5, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6173334, positions_per_block: 32768, live_blocks: 189 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 180531, positions_per_block: 4096, live_blocks: 45 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 21528, positions_per_block: 1024, live_blocks: 22 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7896, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, @@ -189,22 +190,26 @@ pub(crate) static FP128_D64_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ ]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }]; +pub(crate) static CATALOG_POTENTIAL_A_DIMENSIONS: &[usize] = &[64, 128, 256]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_B_DIMENSIONS: &[usize] = &[64, 128]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_D_DIMENSIONS: &[usize] = &[64, 128]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; +pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64, 128, 256]; #[rustfmt::skip] pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_dense", + family_name: "fp128_dense", protocol_epoch: 1, cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinEstimatedProofPayload, + selection_policy: SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, setup_field_budget: None, min_offloaded_witness_contraction: 3, sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, sis_security_policy: SisSecurityPolicyId::Quantum128BitADPS16, sis_table_digest: SisTableDigest([0xb4, 0x65, 0x7f, 0x62, 0x90, 0x61, 0x5c, 0xf3, 0x58, 0x55, 0x77, 0xd7, 0xad, 0x51, 0x9f, 0x9d, 0xc5, 0x5d, 0x4b, 0x8d, 0xcc, 0x63, 0x16, 0x11, 0x1b, 0x26, 0x70, 0x42, 0xac, 0x3b, 0x92, 0x94]), - uniform_ring_dimension: 64, - setup_prefix_inner_ring_dimension: 64, + uniform_ring_dimension: 256, + setup_prefix_inner_ring_dimension: 256, decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 128, log_open_bound: None }, ring_subfield_norm_bound: 1, claim_ext_degree: 1, @@ -212,9 +217,9 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::AdaptiveDimension { num_search_levels: 2, uniform_suffix_dimension: 64, potential_a_dimensions: CATALOG_POTENTIAL_A_DIMENSIONS, potential_b_dimensions: CATALOG_POTENTIAL_B_DIMENSIONS, potential_d_dimensions: CATALOG_POTENTIAL_D_DIMENSIONS }, ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, + ring_challenge_config_digest: 3458533356553718245, key_count: 10, - key_digest: 7611278421477819350, + key_digest: 16961820471072486774, }; diff --git a/crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk.rs b/crates/akita-schedules/src/generated/fp128_dense_multi_chunk.rs similarity index 72% rename from crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk.rs rename to crates/akita-schedules/src/generated/fp128_dense_multi_chunk.rs index d35e0a1a0..1e60ff279 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk.rs +++ b/crates/akita-schedules/src/generated/fp128_dense_multi_chunk.rs @@ -7,12 +7,12 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] -pub(crate) static FP128_D64_DENSE_MULTI_CHUNK_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ +pub(crate) static FP128_DENSE_MULTI_CHUNK_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 1), num_digits_inner: 43, num_digits_fold: 4, @@ -22,34 +22,37 @@ pub(crate) static FP128_D64_DENSE_MULTI_CHUNK_SCHEDULES: &[GeneratedFoldSchedule witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 8 }, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 39225, positions_per_block: 512, live_blocks: 77 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 8 } }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 36947, positions_per_block: 2048, live_blocks: 19 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 13791, positions_per_block: 1024, live_blocks: 14 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6360, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 39225, positions_per_block: 512, live_blocks: 77 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 8 } }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 24848, positions_per_block: 1024, live_blocks: 25 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8179, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, ]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }]; +pub(crate) static CATALOG_POTENTIAL_A_DIMENSIONS: &[usize] = &[64, 128, 256]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_B_DIMENSIONS: &[usize] = &[64, 128]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_D_DIMENSIONS: &[usize] = &[64, 128]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; #[rustfmt::skip] pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_dense_multi_chunk", + family_name: "fp128_dense_multi_chunk", protocol_epoch: 1, cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinEstimatedProofPayload, + selection_policy: SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, setup_field_budget: None, min_offloaded_witness_contraction: 3, sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, sis_security_policy: SisSecurityPolicyId::Quantum128BitADPS16, sis_table_digest: SisTableDigest([0xb4, 0x65, 0x7f, 0x62, 0x90, 0x61, 0x5c, 0xf3, 0x58, 0x55, 0x77, 0xd7, 0xad, 0x51, 0x9f, 0x9d, 0xc5, 0x5d, 0x4b, 0x8d, 0xcc, 0x63, 0x16, 0x11, 0x1b, 0x26, 0x70, 0x42, 0xac, 0x3b, 0x92, 0x94]), - uniform_ring_dimension: 64, - setup_prefix_inner_ring_dimension: 64, + uniform_ring_dimension: 256, + setup_prefix_inner_ring_dimension: 256, decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 128, log_open_bound: None }, ring_subfield_norm_bound: 1, claim_ext_degree: 1, @@ -57,9 +60,9 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 8, num_activated_levels: 2 }, recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::AdaptiveDimension { num_search_levels: 2, uniform_suffix_dimension: 64, potential_a_dimensions: CATALOG_POTENTIAL_A_DIMENSIONS, potential_b_dimensions: CATALOG_POTENTIAL_B_DIMENSIONS, potential_d_dimensions: CATALOG_POTENTIAL_D_DIMENSIONS }, ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, + ring_challenge_config_digest: 3458533356553718245, key_count: 1, - key_digest: 15867038388366469728, + key_digest: 1190293855520516942, }; diff --git a/crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk_precommitted.rs b/crates/akita-schedules/src/generated/fp128_dense_multi_chunk_precommitted.rs similarity index 96% rename from crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk_precommitted.rs rename to crates/akita-schedules/src/generated/fp128_dense_multi_chunk_precommitted.rs index 40a5be33a..43f5994a7 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_dense_multi_chunk_precommitted.rs @@ -5,7 +5,7 @@ use super::{ }; #[rustfmt::skip] -pub(crate) static FP128_D64_DENSE_MULTI_CHUNK_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ +pub(crate) static FP128_DENSE_MULTI_CHUNK_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 8, live_blocks: 32 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 43, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 8, live_blocks: 32 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 43, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 8, live_blocks: 64 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 43, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, diff --git a/crates/akita-schedules/src/generated/fp128_d64_dense_precommitted.rs b/crates/akita-schedules/src/generated/fp128_dense_precommitted.rs similarity index 97% rename from crates/akita-schedules/src/generated/fp128_d64_dense_precommitted.rs rename to crates/akita-schedules/src/generated/fp128_dense_precommitted.rs index 095db3f11..1d8c4999c 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_dense_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_dense_precommitted.rs @@ -5,7 +5,7 @@ use super::{ }; #[rustfmt::skip] -pub(crate) static FP128_D64_DENSE_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ +pub(crate) static FP128_DENSE_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 16, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 43, inner_output_rank: 5, inner_coeff_linf_bound: 1048575, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 32, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 43, inner_output_rank: 5, inner_coeff_linf_bound: 1048575, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 32, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 43, inner_output_rank: 5, inner_coeff_linf_bound: 1048575, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, diff --git a/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot.rs b/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot.rs deleted file mode 100644 index 75db92a3f..000000000 --- a/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot.rs +++ /dev/null @@ -1,65 +0,0 @@ -// Generated by `cargo run --release -p akita-planner --features catalog-gen --bin gen_schedule_tables -- ` -#[allow(unused_imports)] -use super::{ - ChunkedWitnessCfg, CommitmentPayloadMode, CommitmentRingDims, CommittedGroupProfile, - DecompositionParams, GeneratedBlockGeometry, GeneratedCommittedGroup, - GeneratedFoldScheduleEntry, GeneratedInnerCommitMatrix, GeneratedOpenCommitMatrix, - GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, - GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, - GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, -}; - -#[rustfmt::skip] -pub(crate) static FP128_MIXED_DIM_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 1), num_digits_inner: 1, num_digits_fold: 3, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16777216, positions_per_block: 32768, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, - precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, - witness_partition: GeneratedWitnessPartition::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 570470, positions_per_block: 4096, live_blocks: 140 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 53201, positions_per_block: 2048, live_blocks: 26 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 15597, positions_per_block: 1024, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6744, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, - }, -]; - -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }, CommitmentRingDims { inner: 128, outer: 64, opening: 64 }, CommitmentRingDims { inner: 128, outer: 128, opening: 128 }, CommitmentRingDims { inner: 256, outer: 128, opening: 128 }]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64, 128, 256]; -#[rustfmt::skip] -pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_mixed_dim_onehot", - protocol_epoch: 1, - cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, - setup_field_budget: None, - min_offloaded_witness_contraction: 3, - sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, - sis_security_policy: SisSecurityPolicyId::Quantum128BitADPS16, - sis_table_digest: SisTableDigest([0xb4, 0x65, 0x7f, 0x62, 0x90, 0x61, 0x5c, 0xf3, 0x58, 0x55, 0x77, 0xd7, 0xad, 0x51, 0x9f, 0x9d, 0xc5, 0x5d, 0x4b, 0x8d, 0xcc, 0x63, 0x16, 0x11, 0x1b, 0x26, 0x70, 0x42, 0xac, 0x3b, 0x92, 0x94]), - uniform_ring_dimension: 256, - setup_prefix_inner_ring_dimension: 256, - decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 1, log_open_bound: Some(128) }, - ring_subfield_norm_bound: 1, - claim_ext_degree: 1, - chal_ext_degree: 1, - basis_range: (3, 6), - witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, - recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, - ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 3458533356553718245, - key_count: 1, - key_digest: 4854142397157369671, -}; diff --git a/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot_precommitted.rs b/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot_precommitted.rs deleted file mode 100644 index 9334d93ee..000000000 --- a/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot_precommitted.rs +++ /dev/null @@ -1,15 +0,0 @@ -// Generated by `cargo run --release -p akita-planner --features catalog-gen --bin gen_schedule_tables -- ` -use super::{ - GeneratedBlockGeometry, GeneratedCommittedGroup, GeneratedInnerCommitMatrix, - GeneratedOuterCommitMatrix, GeneratedPrecommittedProfile, PolynomialGroupLayout, -}; - -#[rustfmt::skip] -pub(crate) static FP128_MIXED_DIM_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 64, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 1023, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 1023, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 256, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 256, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, inner_coeff_linf_bound: 1023, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 512, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, -]; diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot.rs b/crates/akita-schedules/src/generated/fp128_onehot.rs similarity index 82% rename from crates/akita-schedules/src/generated/fp128_d64_onehot.rs rename to crates/akita-schedules/src/generated/fp128_onehot.rs index 4cdb48b39..261e910ca 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot.rs @@ -7,12 +7,12 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ +pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(12, 1), num_digits_inner: 1, num_digits_fold: 2, @@ -21,34 +21,36 @@ pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, - recursive_folds: &[], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1909, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, + recursive_folds: &[ + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1909, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + ], + terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1883, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(14, 1), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 32, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 64, positions_per_block: 16, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2051, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2287, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1993, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(15, 1), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 64, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 64, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2115, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1985, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1993, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, + terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1883, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { @@ -66,14 +68,16 @@ pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 1), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 512, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 1), num_digits_inner: 1, num_digits_fold: 1, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, - recursive_folds: &[], - terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1979, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, + recursive_folds: &[ + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1983, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + ], + terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1883, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { @@ -110,15 +114,15 @@ pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(18, 1), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4096, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(18, 1), num_digits_inner: 1, num_digits_fold: 1, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 512, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3011, positions_per_block: 512, live_blocks: 6 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2329, positions_per_block: 512, live_blocks: 5 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3519, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2461, positions_per_block: 512, live_blocks: 5 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2197, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, @@ -126,14 +130,14 @@ pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 1), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16384, positions_per_block: 1024, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4096, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 5411, positions_per_block: 512, live_blocks: 11 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3800, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1908, positions_per_block: 256, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4013, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, @@ -158,14 +162,14 @@ pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 2), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16384, positions_per_block: 2048, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4096, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7459, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 5192, positions_per_block: 512, live_blocks: 11 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4013, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, @@ -191,15 +195,15 @@ pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 4), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16384, positions_per_block: 4096, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4096, positions_per_block: 1024, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 11555, positions_per_block: 1024, live_blocks: 12 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 5976, positions_per_block: 512, live_blocks: 12 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3956, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3620, positions_per_block: 256, live_blocks: 15 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7576, positions_per_block: 512, live_blocks: 15 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4084, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, @@ -245,16 +249,15 @@ pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(28, 1), num_digits_inner: 1, num_digits_fold: 3, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4194304, positions_per_block: 16384, live_blocks: 256 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(25, 1), num_digits_inner: 1, num_digits_fold: 2, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 131072, positions_per_block: 2048, live_blocks: 64 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 104846, positions_per_block: 2048, live_blocks: 52 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22305, positions_per_block: 1024, live_blocks: 22 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7896, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 9796, positions_per_block: 512, live_blocks: 20 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8173, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], @@ -262,34 +265,52 @@ pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(30, 1), num_digits_inner: 1, num_digits_fold: 3, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16777216, positions_per_block: 32768, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(28, 1), num_digits_inner: 1, num_digits_fold: 2, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1048576, positions_per_block: 8192, live_blocks: 128 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 209038, positions_per_block: 4096, live_blocks: 52 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22872, positions_per_block: 1024, live_blocks: 23 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 110351, positions_per_block: 2048, live_blocks: 54 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22821, positions_per_block: 1024, live_blocks: 23 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8088, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, + GeneratedFoldScheduleEntry { + root: GeneratedRootFold { + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(30, 1), num_digits_inner: 1, num_digits_fold: 3, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4194304, positions_per_block: 16384, live_blocks: 256 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + precommitted_groups: &[], + open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, + witness_partition: GeneratedWitnessPartition::Single, + }, + recursive_folds: &[ + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 71364, positions_per_block: 512, live_blocks: 140 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 57135, positions_per_block: 2048, live_blocks: 28 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16113, positions_per_block: 1024, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6744, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + ], + terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, + }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(30, 4), num_digits_inner: 1, num_digits_fold: 3, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16777216, positions_per_block: 65536, live_blocks: 256 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4194304, positions_per_block: 32768, live_blocks: 128 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 461497, positions_per_block: 4096, live_blocks: 113 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 46235, positions_per_block: 2048, live_blocks: 23 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 14823, positions_per_block: 1024, live_blocks: 15 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6552, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 570127, positions_per_block: 4096, live_blocks: 140 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 53201, positions_per_block: 2048, live_blocks: 26 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 15597, positions_per_block: 1024, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6744, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], @@ -298,16 +319,16 @@ pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 1), num_digits_inner: 1, num_digits_fold: 3, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 67108864, positions_per_block: 65536, live_blocks: 1024 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16777216, positions_per_block: 32768, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 461497, positions_per_block: 4096, live_blocks: 113 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 46235, positions_per_block: 2048, live_blocks: 23 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 14823, positions_per_block: 1024, live_blocks: 15 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6552, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 570127, positions_per_block: 4096, live_blocks: 140 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 53201, positions_per_block: 2048, live_blocks: 26 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 15597, positions_per_block: 1024, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6744, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], @@ -336,54 +357,72 @@ pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 4), num_digits_inner: 1, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 67108864, positions_per_block: 131072, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 4), num_digits_inner: 1, num_digits_fold: 3, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16777216, positions_per_block: 65536, live_blocks: 256 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1141647, positions_per_block: 8192, live_blocks: 140 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 69585, positions_per_block: 2048, live_blocks: 34 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 17661, positions_per_block: 1024, live_blocks: 18 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7128, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 284868, positions_per_block: 2048, live_blocks: 140 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 105963, positions_per_block: 2048, live_blocks: 52 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22305, positions_per_block: 1024, live_blocks: 22 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7896, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(40, 1), num_digits_inner: 1, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 17179869184, positions_per_block: 1048576, live_blocks: 16384 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(36, 1), num_digits_inner: 1, num_digits_fold: 3, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 268435456, positions_per_block: 65536, live_blocks: 4096 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, + open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 9126970, positions_per_block: 32768, live_blocks: 279 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 203751, positions_per_block: 4096, live_blocks: 50 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22488, positions_per_block: 1024, live_blocks: 22 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2196582, positions_per_block: 8192, live_blocks: 269 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 102867, positions_per_block: 2048, live_blocks: 51 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22047, positions_per_block: 1024, live_blocks: 22 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7896, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, + GeneratedFoldScheduleEntry { + root: GeneratedRootFold { + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(40, 1), num_digits_inner: 1, num_digits_fold: 3, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4294967296, positions_per_block: 524288, live_blocks: 8192 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, + precommitted_groups: &[], + open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, + witness_partition: GeneratedWitnessPartition::Single, + }, + recursive_folds: &[ + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 5259913, positions_per_block: 16384, live_blocks: 322 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 128, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 242623, positions_per_block: 4096, live_blocks: 60 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 24408, positions_per_block: 1024, live_blocks: 24 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8014, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + ], + terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, + }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(44, 1), num_digits_inner: 1, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 274877906944, positions_per_block: 4194304, live_blocks: 65536 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 68719476736, positions_per_block: 2097152, live_blocks: 32768 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, + open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 39322725, positions_per_block: 32768, live_blocks: 1201 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 5, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 526081, positions_per_block: 8192, live_blocks: 65 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 50235, positions_per_block: 2048, live_blocks: 25 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 15339, positions_per_block: 1024, live_blocks: 15 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6552, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 12616005, positions_per_block: 16384, live_blocks: 771 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 660935, positions_per_block: 8192, live_blocks: 81 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 54363, positions_per_block: 2048, live_blocks: 27 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 15855, positions_per_block: 1024, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6744, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], @@ -391,17 +430,17 @@ pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(50, 1), num_digits_inner: 1, num_digits_fold: 5, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 17592186044416, positions_per_block: 33554432, live_blocks: 524288 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(50, 1), num_digits_inner: 1, num_digits_fold: 4, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 4398046511104, positions_per_block: 16777216, live_blocks: 262144 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, + open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 370672784, positions_per_block: 131072, live_blocks: 2829 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 5, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1629490, positions_per_block: 8192, live_blocks: 199 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 84807, positions_per_block: 2048, live_blocks: 42 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 19725, positions_per_block: 1024, live_blocks: 20 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 403703058, positions_per_block: 131072, live_blocks: 3081 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 5, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1716178, positions_per_block: 8192, live_blocks: 210 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 87645, positions_per_block: 2048, live_blocks: 43 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 19983, positions_per_block: 1024, live_blocks: 20 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7512, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, @@ -411,22 +450,26 @@ pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ ]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }]; +pub(crate) static CATALOG_POTENTIAL_A_DIMENSIONS: &[usize] = &[64, 128, 256]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_B_DIMENSIONS: &[usize] = &[64, 128]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_D_DIMENSIONS: &[usize] = &[64, 128]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; +pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64, 128, 256]; #[rustfmt::skip] pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_onehot", + family_name: "fp128_onehot", protocol_epoch: 1, cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinEstimatedProofPayload, + selection_policy: SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, setup_field_budget: None, min_offloaded_witness_contraction: 3, sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, sis_security_policy: SisSecurityPolicyId::Quantum128BitADPS16, sis_table_digest: SisTableDigest([0xb4, 0x65, 0x7f, 0x62, 0x90, 0x61, 0x5c, 0xf3, 0x58, 0x55, 0x77, 0xd7, 0xad, 0x51, 0x9f, 0x9d, 0xc5, 0x5d, 0x4b, 0x8d, 0xcc, 0x63, 0x16, 0x11, 0x1b, 0x26, 0x70, 0x42, 0xac, 0x3b, 0x92, 0x94]), - uniform_ring_dimension: 64, - setup_prefix_inner_ring_dimension: 64, + uniform_ring_dimension: 256, + setup_prefix_inner_ring_dimension: 256, decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 1, log_open_bound: Some(128) }, ring_subfield_norm_bound: 1, claim_ext_degree: 1, @@ -434,9 +477,9 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::AdaptiveDimension { num_search_levels: 2, uniform_suffix_dimension: 64, potential_a_dimensions: CATALOG_POTENTIAL_A_DIMENSIONS, potential_b_dimensions: CATALOG_POTENTIAL_B_DIMENSIONS, potential_d_dimensions: CATALOG_POTENTIAL_D_DIMENSIONS }, ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, - key_count: 24, - key_digest: 9739485853845478637, + ring_challenge_config_digest: 3458533356553718245, + key_count: 26, + key_digest: 17058955708590941206, }; diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk.rs similarity index 81% rename from crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk.rs rename to crates/akita-schedules/src/generated/fp128_onehot_multi_chunk.rs index 23dfa05de..c47427fda 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk.rs @@ -7,27 +7,28 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_MULTI_CHUNK_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ +pub(crate) static FP128_ONEHOT_MULTI_CHUNK_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 1), num_digits_inner: 1, num_digits_fold: 3, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 67108864, positions_per_block: 32768, live_blocks: 2048 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 1), num_digits_inner: 1, num_digits_fold: 2, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16777216, positions_per_block: 32768, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 8 }, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1227406, positions_per_block: 4096, live_blocks: 300 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 8 } }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 209169, positions_per_block: 4096, live_blocks: 52 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22872, positions_per_block: 1024, live_blocks: 23 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8088, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 568516, positions_per_block: 2048, live_blocks: 278 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 8 } }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 406547, positions_per_block: 4096, live_blocks: 100 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 42881, positions_per_block: 2048, live_blocks: 21 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 14307, positions_per_block: 1024, live_blocks: 14 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6360, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, @@ -55,22 +56,26 @@ pub(crate) static FP128_D64_ONEHOT_MULTI_CHUNK_SCHEDULES: &[GeneratedFoldSchedul ]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }]; +pub(crate) static CATALOG_POTENTIAL_A_DIMENSIONS: &[usize] = &[64, 128, 256]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_B_DIMENSIONS: &[usize] = &[64, 128]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_D_DIMENSIONS: &[usize] = &[64, 128]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; +pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64, 256]; #[rustfmt::skip] pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_onehot_multi_chunk", + family_name: "fp128_onehot_multi_chunk", protocol_epoch: 1, cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinEstimatedProofPayload, + selection_policy: SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, setup_field_budget: None, min_offloaded_witness_contraction: 3, sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, sis_security_policy: SisSecurityPolicyId::Quantum128BitADPS16, sis_table_digest: SisTableDigest([0xb4, 0x65, 0x7f, 0x62, 0x90, 0x61, 0x5c, 0xf3, 0x58, 0x55, 0x77, 0xd7, 0xad, 0x51, 0x9f, 0x9d, 0xc5, 0x5d, 0x4b, 0x8d, 0xcc, 0x63, 0x16, 0x11, 0x1b, 0x26, 0x70, 0x42, 0xac, 0x3b, 0x92, 0x94]), - uniform_ring_dimension: 64, - setup_prefix_inner_ring_dimension: 64, + uniform_ring_dimension: 256, + setup_prefix_inner_ring_dimension: 256, decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 1, log_open_bound: Some(128) }, ring_subfield_norm_bound: 1, claim_ext_degree: 1, @@ -78,9 +83,9 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 8, num_activated_levels: 2 }, recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::AdaptiveDimension { num_search_levels: 2, uniform_suffix_dimension: 64, potential_a_dimensions: CATALOG_POTENTIAL_A_DIMENSIONS, potential_b_dimensions: CATALOG_POTENTIAL_B_DIMENSIONS, potential_d_dimensions: CATALOG_POTENTIAL_D_DIMENSIONS }, ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, + ring_challenge_config_digest: 3458533356553718245, key_count: 2, - key_digest: 14362940196028522173, + key_digest: 3783944043367586616, }; diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_precommitted.rs similarity index 96% rename from crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_precommitted.rs rename to crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_precommitted.rs index 9d81ea8ab..497cd8ce6 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_precommitted.rs @@ -5,7 +5,7 @@ use super::{ }; #[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_MULTI_CHUNK_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ +pub(crate) static FP128_ONEHOT_MULTI_CHUNK_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 64, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 2047, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 64, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 128, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 2047, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w2r2.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2.rs similarity index 55% rename from crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w2r2.rs rename to crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2.rs index eb08a8e4d..3e150f1ef 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w2r2.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2.rs @@ -7,41 +7,57 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ +pub(crate) static FP128_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(14, 1), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 4, live_blocks: 64 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 64, positions_per_block: 8, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 2 }, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6045, positions_per_block: 256, live_blocks: 24 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 2 } }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 5944, positions_per_block: 512, live_blocks: 12 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3956, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3663, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 2 } }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, + GeneratedFoldScheduleEntry { + root: GeneratedRootFold { + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(14, 1), num_digits_inner: 1, num_digits_fold: 2, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 16, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + precommitted_groups: &[ + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 256, num_positions_per_block: 128, num_live_blocks: 2, log_basis_inner: 3, num_digits_inner: 1, inner_commit_matrix: InnerCommitMatrixParams::new_unchecked(SisSecurityPolicyId::Quantum128BitADPS16, SisTableDigest([180, 101, 127, 98, 144, 97, 92, 243, 88, 85, 119, 215, 173, 81, 159, 157, 197, 93, 75, 141, 204, 99, 22, 17, 27, 38, 112, 66, 172, 59, 146, 148]), SisModulusProfileId::Q128OffsetA7F7, 2, 128, 2047, 64), log_basis_outer: 3, num_digits_outer: 43, outer_commit_matrix: OuterCommitMatrixParams::new_unchecked(SisSecurityPolicyId::Quantum128BitADPS16, SisTableDigest([180, 101, 127, 98, 144, 97, 92, 243, 88, 85, 119, 215, 173, 81, 159, 157, 197, 93, 75, 141, 204, 99, 22, 17, 27, 38, 112, 66, 172, 59, 146, 148]), SisModulusProfileId::Q128OffsetA7F7, 1, 172, 7, 64) }, num_digits_fold: 1, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + ], + open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, + witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 2 }, + }, + recursive_folds: &[ + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3558, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 2 } }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + ], + terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, + }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 1), num_digits_inner: 1, num_digits_fold: 3, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 67108864, positions_per_block: 65536, live_blocks: 1024 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16777216, positions_per_block: 32768, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 2 }, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 658105, positions_per_block: 4096, live_blocks: 161 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 2 } }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 75003, positions_per_block: 2048, live_blocks: 37 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 18435, positions_per_block: 1024, live_blocks: 19 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7320, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 963343, positions_per_block: 4096, live_blocks: 236 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 2 } }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 94353, positions_per_block: 2048, live_blocks: 47 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 21015, positions_per_block: 1024, live_blocks: 21 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7704, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], @@ -50,22 +66,26 @@ pub(crate) static FP128_D64_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES: &[GeneratedFoldSc ]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }]; +pub(crate) static CATALOG_POTENTIAL_A_DIMENSIONS: &[usize] = &[64, 128, 256]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_B_DIMENSIONS: &[usize] = &[64, 128]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_D_DIMENSIONS: &[usize] = &[64, 128]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; +pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64, 256]; #[rustfmt::skip] pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_onehot_multi_chunk_w2r2", + family_name: "fp128_onehot_multi_chunk_w2r2", protocol_epoch: 1, cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinEstimatedProofPayload, + selection_policy: SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, setup_field_budget: None, min_offloaded_witness_contraction: 3, sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, sis_security_policy: SisSecurityPolicyId::Quantum128BitADPS16, sis_table_digest: SisTableDigest([0xb4, 0x65, 0x7f, 0x62, 0x90, 0x61, 0x5c, 0xf3, 0x58, 0x55, 0x77, 0xd7, 0xad, 0x51, 0x9f, 0x9d, 0xc5, 0x5d, 0x4b, 0x8d, 0xcc, 0x63, 0x16, 0x11, 0x1b, 0x26, 0x70, 0x42, 0xac, 0x3b, 0x92, 0x94]), - uniform_ring_dimension: 64, - setup_prefix_inner_ring_dimension: 64, + uniform_ring_dimension: 256, + setup_prefix_inner_ring_dimension: 256, decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 1, log_open_bound: Some(128) }, ring_subfield_norm_bound: 1, claim_ext_degree: 1, @@ -73,9 +93,9 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 2, num_activated_levels: 2 }, recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::AdaptiveDimension { num_search_levels: 2, uniform_suffix_dimension: 64, potential_a_dimensions: CATALOG_POTENTIAL_A_DIMENSIONS, potential_b_dimensions: CATALOG_POTENTIAL_B_DIMENSIONS, potential_d_dimensions: CATALOG_POTENTIAL_D_DIMENSIONS }, ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, - key_count: 2, - key_digest: 7609967829657770616, + ring_challenge_config_digest: 3458533356553718245, + key_count: 3, + key_digest: 690501068951054480, }; diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w2r2_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2_precommitted.rs similarity index 96% rename from crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w2r2_precommitted.rs rename to crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2_precommitted.rs index ba3ce9340..20165b946 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w2r2_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2_precommitted.rs @@ -5,7 +5,7 @@ use super::{ }; #[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ +pub(crate) static FP128_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 2047, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 256, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 2047, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w4r2.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2.rs similarity index 68% rename from crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w4r2.rs rename to crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2.rs index 324d98868..afcdcbd4b 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w4r2.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2.rs @@ -7,25 +7,25 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ +pub(crate) static FP128_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 1), num_digits_inner: 1, num_digits_fold: 3, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 67108864, positions_per_block: 32768, live_blocks: 2048 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 1), num_digits_inner: 1, num_digits_fold: 2, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16777216, positions_per_block: 32768, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[], open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 4 }, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 834190, positions_per_block: 4096, live_blocks: 204 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 4 } }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 118865, positions_per_block: 2048, live_blocks: 59 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 24111, positions_per_block: 1024, live_blocks: 24 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8014, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 306372, positions_per_block: 1024, live_blocks: 300 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_fold: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 4 } }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 221291, positions_per_block: 4096, live_blocks: 55 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 23448, positions_per_block: 1024, live_blocks: 23 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 8088, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], @@ -34,22 +34,26 @@ pub(crate) static FP128_D64_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES: &[GeneratedFoldSc ]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }]; +pub(crate) static CATALOG_POTENTIAL_A_DIMENSIONS: &[usize] = &[64, 128, 256]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; +pub(crate) static CATALOG_POTENTIAL_B_DIMENSIONS: &[usize] = &[64, 128]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_D_DIMENSIONS: &[usize] = &[64, 128]; +#[rustfmt::skip] +pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64, 256]; #[rustfmt::skip] pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_onehot_multi_chunk_w4r2", + family_name: "fp128_onehot_multi_chunk_w4r2", protocol_epoch: 1, cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinEstimatedProofPayload, + selection_policy: SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, setup_field_budget: None, min_offloaded_witness_contraction: 3, sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, sis_security_policy: SisSecurityPolicyId::Quantum128BitADPS16, sis_table_digest: SisTableDigest([0xb4, 0x65, 0x7f, 0x62, 0x90, 0x61, 0x5c, 0xf3, 0x58, 0x55, 0x77, 0xd7, 0xad, 0x51, 0x9f, 0x9d, 0xc5, 0x5d, 0x4b, 0x8d, 0xcc, 0x63, 0x16, 0x11, 0x1b, 0x26, 0x70, 0x42, 0xac, 0x3b, 0x92, 0x94]), - uniform_ring_dimension: 64, - setup_prefix_inner_ring_dimension: 64, + uniform_ring_dimension: 256, + setup_prefix_inner_ring_dimension: 256, decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 1, log_open_bound: Some(128) }, ring_subfield_norm_bound: 1, claim_ext_degree: 1, @@ -57,9 +61,9 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 4, num_activated_levels: 2 }, recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::AdaptiveDimension { num_search_levels: 2, uniform_suffix_dimension: 64, potential_a_dimensions: CATALOG_POTENTIAL_A_DIMENSIONS, potential_b_dimensions: CATALOG_POTENTIAL_B_DIMENSIONS, potential_d_dimensions: CATALOG_POTENTIAL_D_DIMENSIONS }, ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, + ring_challenge_config_digest: 3458533356553718245, key_count: 1, - key_digest: 3286325418226561651, + key_digest: 8522104887241228783, }; diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w4r2_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2_precommitted.rs similarity index 96% rename from crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w4r2_precommitted.rs rename to crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2_precommitted.rs index c48341c31..d0dc57c70 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w4r2_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2_precommitted.rs @@ -5,7 +5,7 @@ use super::{ }; #[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ +pub(crate) static FP128_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 2047, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 128, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 2047, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs similarity index 97% rename from crates/akita-schedules/src/generated/fp128_d64_onehot_precommitted.rs rename to crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs index e9362bc6c..713adebb2 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs @@ -5,7 +5,7 @@ use super::{ }; #[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ +pub(crate) static FP128_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 256, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive.rs b/crates/akita-schedules/src/generated/fp128_onehot_recursive.rs similarity index 67% rename from crates/akita-schedules/src/generated/fp128_d64_onehot_recursive.rs rename to crates/akita-schedules/src/generated/fp128_onehot_recursive.rs index 69d1fd2d3..422a8af60 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_recursive.rs @@ -7,16 +7,16 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_RECURSIVE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ +pub(crate) static FP128_ONEHOT_RECURSIVE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 2), num_digits_inner: 1, num_digits_fold: 4, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 67108864, positions_per_block: 65536, live_blocks: 1024 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 2), num_digits_inner: 1, num_digits_fold: 3, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16777216, positions_per_block: 32768, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[ GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 1), num_live_ring_elements_per_claim: 1024, num_positions_per_block: 256, num_live_blocks: 4, log_basis_inner: 3, num_digits_inner: 1, inner_commit_matrix: InnerCommitMatrixParams::new_unchecked(SisSecurityPolicyId::Quantum128BitADPS16, SisTableDigest([180, 101, 127, 98, 144, 97, 92, 243, 88, 85, 119, 215, 173, 81, 159, 157, 197, 93, 75, 141, 204, 99, 22, 17, 27, 38, 112, 66, 172, 59, 146, 148]), SisModulusProfileId::Q128OffsetA7F7, 3, 256, 16383, 64), log_basis_outer: 3, num_digits_outer: 43, outer_commit_matrix: OuterCommitMatrixParams::new_unchecked(SisSecurityPolicyId::Quantum128BitADPS16, SisTableDigest([180, 101, 127, 98, 144, 97, 92, 243, 88, 85, 119, 215, 173, 81, 159, 157, 197, 93, 75, 141, 204, 99, 22, 17, 27, 38, 112, 66, 172, 59, 146, 148]), SisModulusProfileId::Q128OffsetA7F7, 1, 516, 7, 64) }, num_digits_fold: 2, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 1), num_live_ring_elements_per_claim: 1024, num_positions_per_block: 256, num_live_blocks: 4, log_basis_inner: 3, num_digits_inner: 1, inner_commit_matrix: InnerCommitMatrixParams::new_unchecked(SisSecurityPolicyId::Quantum128BitADPS16, SisTableDigest([180, 101, 127, 98, 144, 97, 92, 243, 88, 85, 119, 215, 173, 81, 159, 157, 197, 93, 75, 141, 204, 99, 22, 17, 27, 38, 112, 66, 172, 59, 146, 148]), SisModulusProfileId::Q128OffsetA7F7, 3, 256, 16383, 64), log_basis_outer: 3, num_digits_outer: 43, outer_commit_matrix: OuterCommitMatrixParams::new_unchecked(SisSecurityPolicyId::Quantum128BitADPS16, SisTableDigest([180, 101, 127, 98, 144, 97, 92, 243, 88, 85, 119, 215, 173, 81, 159, 157, 197, 93, 75, 141, 204, 99, 22, 17, 27, 38, 112, 66, 172, 59, 146, 148]), SisModulusProfileId::Q128OffsetA7F7, 1, 516, 7, 64) }, num_digits_fold: 2, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, @@ -25,24 +25,29 @@ pub(crate) static FP128_D64_ONEHOT_RECURSIVE_SCHEDULES: &[GeneratedFoldScheduleE witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 794407, positions_per_block: 8192, live_blocks: 97 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: Some(GeneratedSetupPrefixInput { natural_len: 28180480, num_digits_fold: 3, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 524288, positions_per_block: 1024, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } } }), witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 216392, positions_per_block: 4096, live_blocks: 53 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22508, positions_per_block: 1024, live_blocks: 22 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7650, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 187360, positions_per_block: 2048, live_blocks: 92 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: Some(GeneratedSetupPrefixInput { natural_len: 11294208, num_digits_fold: 3, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 65536, positions_per_block: 256, live_blocks: 256 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } } }), witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 257892, positions_per_block: 4096, live_blocks: 63 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: Some(GeneratedSetupPrefixInput { natural_len: 4194304, num_digits_fold: 4, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 65536, positions_per_block: 256, live_blocks: 256 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } } }), witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 115524, positions_per_block: 2048, live_blocks: 57 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 17688, positions_per_block: 1024, live_blocks: 18 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 4 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7128, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, ]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }]; +pub(crate) static CATALOG_POTENTIAL_A_DIMENSIONS: &[usize] = &[64, 128, 256]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; +pub(crate) static CATALOG_POTENTIAL_B_DIMENSIONS: &[usize] = &[64, 128]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_D_DIMENSIONS: &[usize] = &[64, 128]; +#[rustfmt::skip] +pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64, 256]; #[rustfmt::skip] pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_onehot_recursive", + family_name: "fp128_onehot_recursive", protocol_epoch: 1, cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, selection_policy: SelectionPolicyId::MinFirstDirectSetupThenPayload, @@ -51,8 +56,8 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, sis_security_policy: SisSecurityPolicyId::Quantum128BitADPS16, sis_table_digest: SisTableDigest([0xb4, 0x65, 0x7f, 0x62, 0x90, 0x61, 0x5c, 0xf3, 0x58, 0x55, 0x77, 0xd7, 0xad, 0x51, 0x9f, 0x9d, 0xc5, 0x5d, 0x4b, 0x8d, 0xcc, 0x63, 0x16, 0x11, 0x1b, 0x26, 0x70, 0x42, 0xac, 0x3b, 0x92, 0x94]), - uniform_ring_dimension: 64, - setup_prefix_inner_ring_dimension: 64, + uniform_ring_dimension: 256, + setup_prefix_inner_ring_dimension: 256, decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 1, log_open_bound: Some(128) }, ring_subfield_norm_bound: 1, claim_ext_degree: 1, @@ -60,9 +65,9 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: true, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::AdaptiveDimension { num_search_levels: 2, uniform_suffix_dimension: 64, potential_a_dimensions: CATALOG_POTENTIAL_A_DIMENSIONS, potential_b_dimensions: CATALOG_POTENTIAL_B_DIMENSIONS, potential_d_dimensions: CATALOG_POTENTIAL_D_DIMENSIONS }, ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, + ring_challenge_config_digest: 3458533356553718245, key_count: 1, - key_digest: 15113775711051904404, + key_digest: 18380497388496919726, }; diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2.rs b/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2.rs similarity index 69% rename from crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2.rs rename to crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2.rs index 37e3f55b0..b9ff50992 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2.rs @@ -7,16 +7,16 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ +pub(crate) static FP128_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 2), num_digits_inner: 1, num_digits_fold: 3, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 67108864, positions_per_block: 65536, live_blocks: 1024 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 2), num_digits_inner: 1, num_digits_fold: 2, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16777216, positions_per_block: 32768, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 } } }, precommitted_groups: &[ GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 1), num_live_ring_elements_per_claim: 1024, num_positions_per_block: 128, num_live_blocks: 8, log_basis_inner: 3, num_digits_inner: 1, inner_commit_matrix: InnerCommitMatrixParams::new_unchecked(SisSecurityPolicyId::Quantum128BitADPS16, SisTableDigest([180, 101, 127, 98, 144, 97, 92, 243, 88, 85, 119, 215, 173, 81, 159, 157, 197, 93, 75, 141, 204, 99, 22, 17, 27, 38, 112, 66, 172, 59, 146, 148]), SisModulusProfileId::Q128OffsetA7F7, 2, 128, 2047, 64), log_basis_outer: 3, num_digits_outer: 43, outer_commit_matrix: OuterCommitMatrixParams::new_unchecked(SisSecurityPolicyId::Quantum128BitADPS16, SisTableDigest([180, 101, 127, 98, 144, 97, 92, 243, 88, 85, 119, 215, 173, 81, 159, 157, 197, 93, 75, 141, 204, 99, 22, 17, 27, 38, 112, 66, 172, 59, 146, 148]), SisModulusProfileId::Q128OffsetA7F7, 1, 688, 7, 64) }, num_digits_fold: 1, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 128, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 1), num_live_ring_elements_per_claim: 1024, num_positions_per_block: 128, num_live_blocks: 8, log_basis_inner: 3, num_digits_inner: 1, inner_commit_matrix: InnerCommitMatrixParams::new_unchecked(SisSecurityPolicyId::Quantum128BitADPS16, SisTableDigest([180, 101, 127, 98, 144, 97, 92, 243, 88, 85, 119, 215, 173, 81, 159, 157, 197, 93, 75, 141, 204, 99, 22, 17, 27, 38, 112, 66, 172, 59, 146, 148]), SisModulusProfileId::Q128OffsetA7F7, 2, 128, 2047, 64), log_basis_outer: 3, num_digits_outer: 43, outer_commit_matrix: OuterCommitMatrixParams::new_unchecked(SisSecurityPolicyId::Quantum128BitADPS16, SisTableDigest([180, 101, 127, 98, 144, 97, 92, 243, 88, 85, 119, 215, 173, 81, 159, 157, 197, 93, 75, 141, 204, 99, 22, 17, 27, 38, 112, 66, 172, 59, 146, 148]), SisModulusProfileId::Q128OffsetA7F7, 1, 688, 7, 64) }, num_digits_fold: 1, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 128, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } } }, @@ -25,25 +25,29 @@ pub(crate) static FP128_D64_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES: &[Gener witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 8 }, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2106753, positions_per_block: 4096, live_blocks: 515 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: Some(GeneratedSetupPrefixInput { natural_len: 28180480, num_digits_fold: 3, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 524288, positions_per_block: 512, live_blocks: 1024 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } } }), witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 8 } }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 699304, positions_per_block: 8192, live_blocks: 86 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: Some(GeneratedSetupPrefixInput { natural_len: 20447232, num_digits_fold: 3, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 524288, positions_per_block: 1024, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } } }), witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 214390, positions_per_block: 4096, live_blocks: 53 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22508, positions_per_block: 1024, live_blocks: 22 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7650, positions_per_block: 1024, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3617, positions_per_block: 512, live_blocks: 8 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2256, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 613793, positions_per_block: 8192, live_blocks: 75 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 5, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: Some(GeneratedSetupPrefixInput { natural_len: 11316224, num_digits_fold: 3, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 65536, positions_per_block: 128, live_blocks: 512 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 5 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 5, slice_count: 1 } } }), witness_partition: GeneratedWitnessPartition::Distributed { num_chunks: 8 } }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1290738, positions_per_block: 8192, live_blocks: 158 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: Some(GeneratedSetupPrefixInput { natural_len: 7814144, num_digits_fold: 3, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 131072, positions_per_block: 512, live_blocks: 256 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } } }), witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 132605, positions_per_block: 2048, live_blocks: 65 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 18291, positions_per_block: 1024, live_blocks: 18 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6797, positions_per_block: 1024, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 3485, positions_per_block: 512, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2124, positions_per_block: 256, live_blocks: 9 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 } }, num_digits_fold: 2, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 6, slice_count: 1 }, incoming_setup_prefix: None, witness_partition: GeneratedWitnessPartition::Single }, ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1656, positions_per_block: 256, live_blocks: 7 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 6 }, num_digits_inner: 1, inner_output_rank: 4, inner_coeff_linf_bound: 1048575, z_admission_linf_cap: 2570, z_rice_low_bits: 9, z_payload_bytes: 26624 }, }, ]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }]; +pub(crate) static CATALOG_POTENTIAL_A_DIMENSIONS: &[usize] = &[64, 128, 256]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; +pub(crate) static CATALOG_POTENTIAL_B_DIMENSIONS: &[usize] = &[64, 128]; +#[rustfmt::skip] +pub(crate) static CATALOG_POTENTIAL_D_DIMENSIONS: &[usize] = &[64, 128]; +#[rustfmt::skip] +pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64, 128, 256]; #[rustfmt::skip] pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_onehot_recursive_multi_chunk_w8r2", + family_name: "fp128_onehot_recursive_multi_chunk_w8r2", protocol_epoch: 1, cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, selection_policy: SelectionPolicyId::MinFirstDirectSetupThenPayload, @@ -52,8 +56,8 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, sis_security_policy: SisSecurityPolicyId::Quantum128BitADPS16, sis_table_digest: SisTableDigest([0xb4, 0x65, 0x7f, 0x62, 0x90, 0x61, 0x5c, 0xf3, 0x58, 0x55, 0x77, 0xd7, 0xad, 0x51, 0x9f, 0x9d, 0xc5, 0x5d, 0x4b, 0x8d, 0xcc, 0x63, 0x16, 0x11, 0x1b, 0x26, 0x70, 0x42, 0xac, 0x3b, 0x92, 0x94]), - uniform_ring_dimension: 64, - setup_prefix_inner_ring_dimension: 64, + uniform_ring_dimension: 256, + setup_prefix_inner_ring_dimension: 256, decomposition: DecompositionParams { log_basis: 3, log_commit_bound: 1, log_open_bound: Some(128) }, ring_subfield_norm_bound: 1, claim_ext_degree: 1, @@ -61,9 +65,9 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 8, num_activated_levels: 2 }, recursive_setup_planning: true, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::AdaptiveDimension { num_search_levels: 2, uniform_suffix_dimension: 64, potential_a_dimensions: CATALOG_POTENTIAL_A_DIMENSIONS, potential_b_dimensions: CATALOG_POTENTIAL_B_DIMENSIONS, potential_d_dimensions: CATALOG_POTENTIAL_D_DIMENSIONS }, ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, + ring_challenge_config_digest: 3458533356553718245, key_count: 1, - key_digest: 5025346065820949610, + key_digest: 8477849330456216878, }; diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2_precommitted.rs similarity index 96% rename from crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2_precommitted.rs rename to crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2_precommitted.rs index 6bbeccc37..acf6c7e86 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2_precommitted.rs @@ -5,7 +5,7 @@ use super::{ }; #[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ +pub(crate) static FP128_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 64, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 2047, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 64, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 128, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 2, inner_coeff_linf_bound: 2047, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_recursive_precommitted.rs similarity index 84% rename from crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_precommitted.rs rename to crates/akita-schedules/src/generated/fp128_onehot_recursive_precommitted.rs index 64d8a2c6e..f6f5e4c9f 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_recursive_precommitted.rs @@ -5,11 +5,12 @@ use super::{ }; #[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_RECURSIVE_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ +pub(crate) static FP128_ONEHOT_RECURSIVE_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 128, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 256, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 256, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 256, live_blocks: 4 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 512, live_blocks: 2 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(20, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 16384, positions_per_block: 1024, live_blocks: 16 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 64, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 3, inner_coeff_linf_bound: 16383, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, ]; diff --git a/crates/akita-schedules/src/generated/fp32_d128_onehot.rs b/crates/akita-schedules/src/generated/fp32_d128_onehot.rs index 2d629861a..392908937 100644 --- a/crates/akita-schedules/src/generated/fp32_d128_onehot.rs +++ b/crates/akita-schedules/src/generated/fp32_d128_onehot.rs @@ -7,8 +7,8 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] @@ -87,8 +87,6 @@ pub(crate) static FP32_D128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, ]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 128, outer: 128, opening: 128 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[128]; #[rustfmt::skip] @@ -111,7 +109,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 128 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 12329058664815196960, key_count: 5, diff --git a/crates/akita-schedules/src/generated/fp32_d256_onehot.rs b/crates/akita-schedules/src/generated/fp32_d256_onehot.rs index 555a91a06..1cdf93644 100644 --- a/crates/akita-schedules/src/generated/fp32_d256_onehot.rs +++ b/crates/akita-schedules/src/generated/fp32_d256_onehot.rs @@ -7,8 +7,8 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] @@ -30,8 +30,6 @@ pub(crate) static FP32_D256_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, ]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 256, outer: 256, opening: 256 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[256]; #[rustfmt::skip] @@ -54,7 +52,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 256 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 3667632896996973001, key_count: 1, diff --git a/crates/akita-schedules/src/generated/fp64_d128_dense.rs b/crates/akita-schedules/src/generated/fp64_d128_dense.rs index 0c6835484..7621bfbb6 100644 --- a/crates/akita-schedules/src/generated/fp64_d128_dense.rs +++ b/crates/akita-schedules/src/generated/fp64_d128_dense.rs @@ -7,8 +7,8 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] @@ -46,8 +46,6 @@ pub(crate) static FP64_D128_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, ]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 128, outer: 128, opening: 128 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[128]; #[rustfmt::skip] @@ -70,7 +68,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 128 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 12329058664815196960, key_count: 2, diff --git a/crates/akita-schedules/src/generated/fp64_d128_onehot.rs b/crates/akita-schedules/src/generated/fp64_d128_onehot.rs index e19d12504..20358ee29 100644 --- a/crates/akita-schedules/src/generated/fp64_d128_onehot.rs +++ b/crates/akita-schedules/src/generated/fp64_d128_onehot.rs @@ -7,8 +7,8 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] @@ -31,8 +31,6 @@ pub(crate) static FP64_D128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, ]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 128, outer: 128, opening: 128 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[128]; #[rustfmt::skip] @@ -55,7 +53,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 128 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 12329058664815196960, key_count: 1, diff --git a/crates/akita-schedules/src/generated/fp64_d256_onehot.rs b/crates/akita-schedules/src/generated/fp64_d256_onehot.rs index 458a6a217..7341838c1 100644 --- a/crates/akita-schedules/src/generated/fp64_d256_onehot.rs +++ b/crates/akita-schedules/src/generated/fp64_d256_onehot.rs @@ -7,8 +7,8 @@ use super::{ GeneratedOuterCommitMatrix, GeneratedRecursiveFold, GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, - OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, + OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, }; #[rustfmt::skip] @@ -32,8 +32,6 @@ pub(crate) static FP64_D256_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, ]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 256, outer: 256, opening: 256 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[256]; #[rustfmt::skip] @@ -56,7 +54,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated basis_range: (3, 6), witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 256 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 3667632896996973001, key_count: 1, diff --git a/crates/akita-schedules/src/generated/mod.rs b/crates/akita-schedules/src/generated/mod.rs index dce0b24b0..b95be3f7f 100644 --- a/crates/akita-schedules/src/generated/mod.rs +++ b/crates/akita-schedules/src/generated/mod.rs @@ -152,9 +152,8 @@ pub struct GeneratedScheduleCatalogIdentity { pub witness_chunk: akita_types::ChunkedWitnessCfg, pub recursive_setup_planning: bool, - /// Complete ordered A/B/D domain used to generate this catalog, including - /// candidates that did not win an emitted row. - pub ring_dimension_candidates: &'static [akita_types::CommitmentRingDims], + /// Complete uniform or adaptive dimension policy used to generate this catalog. + pub ring_dimension_schedule_mode: crate::RingDimensionScheduleMode, pub ring_dimensions: &'static [usize], pub ring_challenge_config_digest: u64, pub key_count: usize, @@ -173,7 +172,7 @@ pub mod validate; pub(crate) mod walk; pub use crate::{ ChunkedWitnessCfg, CommitmentRingDims, DecompositionParams, PlannerCostModelId, - SelectionPolicyId, SisSecurityPolicyId, + RingDimensionScheduleMode, SelectionPolicyId, SisSecurityPolicyId, }; pub use akita_types::{ CommitmentPayloadMode, CommittedGroupProfile, InnerCommitMatrixParams, OuterCommitMatrixParams, @@ -450,54 +449,38 @@ pub(crate) fn validate_certified_bases( } // @generated schedule module wiring begin -#[cfg(feature = "fp128-d128-dense")] -pub mod fp128_d128_dense; -#[cfg(feature = "fp128-d128-dense")] -pub mod fp128_d128_dense_precommitted; -#[cfg(feature = "fp128-d128-onehot")] -pub mod fp128_d128_onehot; -#[cfg(feature = "fp128-d128-onehot")] -pub mod fp128_d128_onehot_precommitted; -#[cfg(feature = "fp128-d256-onehot")] -pub mod fp128_d256_onehot; -#[cfg(feature = "fp128-d256-onehot")] -pub mod fp128_d256_onehot_precommitted; -#[cfg(feature = "fp128-d64-dense")] -pub mod fp128_d64_dense; -#[cfg(feature = "fp128-d64-dense-multi-chunk")] -pub mod fp128_d64_dense_multi_chunk; -#[cfg(feature = "fp128-d64-dense-multi-chunk")] -pub mod fp128_d64_dense_multi_chunk_precommitted; -#[cfg(feature = "fp128-d64-dense")] -pub mod fp128_d64_dense_precommitted; -#[cfg(feature = "fp128-d64-onehot")] -pub mod fp128_d64_onehot; -#[cfg(feature = "fp128-d64-onehot-multi-chunk")] -pub mod fp128_d64_onehot_multi_chunk; -#[cfg(feature = "fp128-d64-onehot-multi-chunk")] -pub mod fp128_d64_onehot_multi_chunk_precommitted; -#[cfg(feature = "fp128-d64-onehot-multi-chunk-w2r2")] -pub mod fp128_d64_onehot_multi_chunk_w2r2; -#[cfg(feature = "fp128-d64-onehot-multi-chunk-w2r2")] -pub mod fp128_d64_onehot_multi_chunk_w2r2_precommitted; -#[cfg(feature = "fp128-d64-onehot-multi-chunk-w4r2")] -pub mod fp128_d64_onehot_multi_chunk_w4r2; -#[cfg(feature = "fp128-d64-onehot-multi-chunk-w4r2")] -pub mod fp128_d64_onehot_multi_chunk_w4r2_precommitted; -#[cfg(feature = "fp128-d64-onehot")] -pub mod fp128_d64_onehot_precommitted; -#[cfg(feature = "fp128-d64-onehot-recursive")] -pub mod fp128_d64_onehot_recursive; -#[cfg(feature = "fp128-d64-onehot-recursive-multi-chunk-w8r2")] -pub mod fp128_d64_onehot_recursive_multi_chunk_w8r2; -#[cfg(feature = "fp128-d64-onehot-recursive-multi-chunk-w8r2")] -pub mod fp128_d64_onehot_recursive_multi_chunk_w8r2_precommitted; -#[cfg(feature = "fp128-d64-onehot-recursive")] -pub mod fp128_d64_onehot_recursive_precommitted; -#[cfg(feature = "fp128-mixed-dim-onehot")] -pub mod fp128_mixed_dim_onehot; -#[cfg(feature = "fp128-mixed-dim-onehot")] -pub mod fp128_mixed_dim_onehot_precommitted; +#[cfg(feature = "fp128-dense")] +pub mod fp128_dense; +#[cfg(feature = "fp128-dense-multi-chunk")] +pub mod fp128_dense_multi_chunk; +#[cfg(feature = "fp128-dense-multi-chunk")] +pub mod fp128_dense_multi_chunk_precommitted; +#[cfg(feature = "fp128-dense")] +pub mod fp128_dense_precommitted; +#[cfg(feature = "fp128-onehot")] +pub mod fp128_onehot; +#[cfg(feature = "fp128-onehot-multi-chunk")] +pub mod fp128_onehot_multi_chunk; +#[cfg(feature = "fp128-onehot-multi-chunk")] +pub mod fp128_onehot_multi_chunk_precommitted; +#[cfg(feature = "fp128-onehot-multi-chunk-w2r2")] +pub mod fp128_onehot_multi_chunk_w2r2; +#[cfg(feature = "fp128-onehot-multi-chunk-w2r2")] +pub mod fp128_onehot_multi_chunk_w2r2_precommitted; +#[cfg(feature = "fp128-onehot-multi-chunk-w4r2")] +pub mod fp128_onehot_multi_chunk_w4r2; +#[cfg(feature = "fp128-onehot-multi-chunk-w4r2")] +pub mod fp128_onehot_multi_chunk_w4r2_precommitted; +#[cfg(feature = "fp128-onehot")] +pub mod fp128_onehot_precommitted; +#[cfg(feature = "fp128-onehot-recursive")] +pub mod fp128_onehot_recursive; +#[cfg(feature = "fp128-onehot-recursive-multi-chunk-w8r2")] +pub mod fp128_onehot_recursive_multi_chunk_w8r2; +#[cfg(feature = "fp128-onehot-recursive-multi-chunk-w8r2")] +pub mod fp128_onehot_recursive_multi_chunk_w8r2_precommitted; +#[cfg(feature = "fp128-onehot-recursive")] +pub mod fp128_onehot_recursive_precommitted; #[cfg(feature = "fp32-d128-onehot")] pub mod fp32_d128_onehot; #[cfg(feature = "fp32-d128-onehot")] @@ -519,116 +502,77 @@ pub mod fp64_d256_onehot; #[cfg(feature = "fp64-d256-onehot")] pub mod fp64_d256_onehot_precommitted; -#[cfg(feature = "fp128-d128-dense")] -pub fn fp128_d128_dense_table() -> GeneratedScheduleTable { +#[cfg(feature = "fp128-dense")] +pub fn fp128_dense_table() -> GeneratedScheduleTable { GeneratedScheduleTable { - entries: fp128_d128_dense::FP128_D128_DENSE_SCHEDULES, + entries: fp128_dense::FP128_DENSE_SCHEDULES, precommitted_profiles: - fp128_d128_dense_precommitted::FP128_D128_DENSE_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_d128_dense::CATALOG_IDENTITY, + fp128_dense_precommitted::FP128_DENSE_SCHEDULES_PRECOMMITTED_PROFILES, + identity: fp128_dense::CATALOG_IDENTITY, } } -#[cfg(feature = "fp128-d128-onehot")] -pub fn fp128_d128_onehot_table() -> GeneratedScheduleTable { +#[cfg(feature = "fp128-dense-multi-chunk")] +pub fn fp128_dense_multi_chunk_table() -> GeneratedScheduleTable { GeneratedScheduleTable { - entries: fp128_d128_onehot::FP128_D128_ONEHOT_SCHEDULES, - precommitted_profiles: - fp128_d128_onehot_precommitted::FP128_D128_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_d128_onehot::CATALOG_IDENTITY, - } -} - -#[cfg(feature = "fp128-d256-onehot")] -pub fn fp128_d256_onehot_table() -> GeneratedScheduleTable { - GeneratedScheduleTable { - entries: fp128_d256_onehot::FP128_D256_ONEHOT_SCHEDULES, - precommitted_profiles: - fp128_d256_onehot_precommitted::FP128_D256_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_d256_onehot::CATALOG_IDENTITY, + entries: fp128_dense_multi_chunk::FP128_DENSE_MULTI_CHUNK_SCHEDULES, + precommitted_profiles: fp128_dense_multi_chunk_precommitted::FP128_DENSE_MULTI_CHUNK_SCHEDULES_PRECOMMITTED_PROFILES, + identity: fp128_dense_multi_chunk::CATALOG_IDENTITY, } } -#[cfg(feature = "fp128-d64-dense")] -pub fn fp128_d64_dense_table() -> GeneratedScheduleTable { +#[cfg(feature = "fp128-onehot")] +pub fn fp128_onehot_table() -> GeneratedScheduleTable { GeneratedScheduleTable { - entries: fp128_d64_dense::FP128_D64_DENSE_SCHEDULES, + entries: fp128_onehot::FP128_ONEHOT_SCHEDULES, precommitted_profiles: - fp128_d64_dense_precommitted::FP128_D64_DENSE_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_d64_dense::CATALOG_IDENTITY, - } -} - -#[cfg(feature = "fp128-d64-dense-multi-chunk")] -pub fn fp128_d64_dense_multi_chunk_table() -> GeneratedScheduleTable { - GeneratedScheduleTable { - entries: fp128_d64_dense_multi_chunk::FP128_D64_DENSE_MULTI_CHUNK_SCHEDULES, - precommitted_profiles: fp128_d64_dense_multi_chunk_precommitted::FP128_D64_DENSE_MULTI_CHUNK_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_d64_dense_multi_chunk::CATALOG_IDENTITY, - } -} - -#[cfg(feature = "fp128-d64-onehot")] -pub fn fp128_d64_onehot_table() -> GeneratedScheduleTable { - GeneratedScheduleTable { - entries: fp128_d64_onehot::FP128_D64_ONEHOT_SCHEDULES, - precommitted_profiles: - fp128_d64_onehot_precommitted::FP128_D64_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_d64_onehot::CATALOG_IDENTITY, - } -} - -#[cfg(feature = "fp128-d64-onehot-multi-chunk")] -pub fn fp128_d64_onehot_multi_chunk_table() -> GeneratedScheduleTable { - GeneratedScheduleTable { - entries: fp128_d64_onehot_multi_chunk::FP128_D64_ONEHOT_MULTI_CHUNK_SCHEDULES, - precommitted_profiles: fp128_d64_onehot_multi_chunk_precommitted::FP128_D64_ONEHOT_MULTI_CHUNK_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_d64_onehot_multi_chunk::CATALOG_IDENTITY, + fp128_onehot_precommitted::FP128_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES, + identity: fp128_onehot::CATALOG_IDENTITY, } } -#[cfg(feature = "fp128-d64-onehot-multi-chunk-w2r2")] -pub fn fp128_d64_onehot_multi_chunk_w2r2_table() -> GeneratedScheduleTable { +#[cfg(feature = "fp128-onehot-multi-chunk")] +pub fn fp128_onehot_multi_chunk_table() -> GeneratedScheduleTable { GeneratedScheduleTable { - entries: fp128_d64_onehot_multi_chunk_w2r2::FP128_D64_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES, - precommitted_profiles: fp128_d64_onehot_multi_chunk_w2r2_precommitted::FP128_D64_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_d64_onehot_multi_chunk_w2r2::CATALOG_IDENTITY, + entries: fp128_onehot_multi_chunk::FP128_ONEHOT_MULTI_CHUNK_SCHEDULES, + precommitted_profiles: fp128_onehot_multi_chunk_precommitted::FP128_ONEHOT_MULTI_CHUNK_SCHEDULES_PRECOMMITTED_PROFILES, + identity: fp128_onehot_multi_chunk::CATALOG_IDENTITY, } } -#[cfg(feature = "fp128-d64-onehot-multi-chunk-w4r2")] -pub fn fp128_d64_onehot_multi_chunk_w4r2_table() -> GeneratedScheduleTable { +#[cfg(feature = "fp128-onehot-multi-chunk-w2r2")] +pub fn fp128_onehot_multi_chunk_w2r2_table() -> GeneratedScheduleTable { GeneratedScheduleTable { - entries: fp128_d64_onehot_multi_chunk_w4r2::FP128_D64_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES, - precommitted_profiles: fp128_d64_onehot_multi_chunk_w4r2_precommitted::FP128_D64_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_d64_onehot_multi_chunk_w4r2::CATALOG_IDENTITY, + entries: fp128_onehot_multi_chunk_w2r2::FP128_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES, + precommitted_profiles: fp128_onehot_multi_chunk_w2r2_precommitted::FP128_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES_PRECOMMITTED_PROFILES, + identity: fp128_onehot_multi_chunk_w2r2::CATALOG_IDENTITY, } } -#[cfg(feature = "fp128-d64-onehot-recursive")] -pub fn fp128_d64_onehot_recursive_table() -> GeneratedScheduleTable { +#[cfg(feature = "fp128-onehot-multi-chunk-w4r2")] +pub fn fp128_onehot_multi_chunk_w4r2_table() -> GeneratedScheduleTable { GeneratedScheduleTable { - entries: fp128_d64_onehot_recursive::FP128_D64_ONEHOT_RECURSIVE_SCHEDULES, - precommitted_profiles: fp128_d64_onehot_recursive_precommitted::FP128_D64_ONEHOT_RECURSIVE_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_d64_onehot_recursive::CATALOG_IDENTITY, + entries: fp128_onehot_multi_chunk_w4r2::FP128_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES, + precommitted_profiles: fp128_onehot_multi_chunk_w4r2_precommitted::FP128_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES_PRECOMMITTED_PROFILES, + identity: fp128_onehot_multi_chunk_w4r2::CATALOG_IDENTITY, } } -#[cfg(feature = "fp128-d64-onehot-recursive-multi-chunk-w8r2")] -pub fn fp128_d64_onehot_recursive_multi_chunk_w8r2_table() -> GeneratedScheduleTable { +#[cfg(feature = "fp128-onehot-recursive")] +pub fn fp128_onehot_recursive_table() -> GeneratedScheduleTable { GeneratedScheduleTable { - entries: fp128_d64_onehot_recursive_multi_chunk_w8r2::FP128_D64_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES, - precommitted_profiles: fp128_d64_onehot_recursive_multi_chunk_w8r2_precommitted::FP128_D64_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_d64_onehot_recursive_multi_chunk_w8r2::CATALOG_IDENTITY, + entries: fp128_onehot_recursive::FP128_ONEHOT_RECURSIVE_SCHEDULES, + precommitted_profiles: fp128_onehot_recursive_precommitted::FP128_ONEHOT_RECURSIVE_SCHEDULES_PRECOMMITTED_PROFILES, + identity: fp128_onehot_recursive::CATALOG_IDENTITY, } } -#[cfg(feature = "fp128-mixed-dim-onehot")] -pub fn fp128_mixed_dim_onehot_table() -> GeneratedScheduleTable { +#[cfg(feature = "fp128-onehot-recursive-multi-chunk-w8r2")] +pub fn fp128_onehot_recursive_multi_chunk_w8r2_table() -> GeneratedScheduleTable { GeneratedScheduleTable { - entries: fp128_mixed_dim_onehot::FP128_MIXED_DIM_ONEHOT_SCHEDULES, - precommitted_profiles: fp128_mixed_dim_onehot_precommitted::FP128_MIXED_DIM_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_mixed_dim_onehot::CATALOG_IDENTITY, + entries: fp128_onehot_recursive_multi_chunk_w8r2::FP128_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES, + precommitted_profiles: fp128_onehot_recursive_multi_chunk_w8r2_precommitted::FP128_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES_PRECOMMITTED_PROFILES, + identity: fp128_onehot_recursive_multi_chunk_w8r2::CATALOG_IDENTITY, } } diff --git a/crates/akita-schedules/src/generated/walk.rs b/crates/akita-schedules/src/generated/walk.rs index cfc2b63c1..025f23f88 100644 --- a/crates/akita-schedules/src/generated/walk.rs +++ b/crates/akita-schedules/src/generated/walk.rs @@ -50,6 +50,7 @@ pub(crate) fn walk_generated_schedule_entry( policy, ring_challenge_config, entry.root.open_commit_matrix.log_basis, + entry.root.open_commit_matrix.ring_dimension as usize, )?; validate_expanded_precommitted_groups(key, &precommitted_groups)?; entry @@ -102,6 +103,11 @@ pub(crate) fn walk_generated_schedule_entry( key.final_group.num_polynomials(), root_params.witness_chunk.num_chunks, )? + .ok_or_else(|| { + AkitaError::InvalidSetup( + "generated root uses unsupported compression-source geometry".to_string(), + ) + })? }; let mut expanded = vec![(root_params, expected_root_w_len, root_output_len)]; @@ -121,7 +127,12 @@ pub(crate) fn walk_generated_schedule_entry( )?; params.witness_chunk = partition_to_chunk(fold.witness_partition, distributed_levels)?; let output_witness_len = - planned_next_witness_len(field_bits, ¶ms, 1, params.witness_chunk.num_chunks)?; + planned_next_witness_len(field_bits, ¶ms, 1, params.witness_chunk.num_chunks)? + .ok_or_else(|| { + AkitaError::InvalidSetup(format!( + "generated recursive fold {index} uses unsupported compression-source geometry" + )) + })?; expanded.push((params, input_witness_len, output_witness_len)); input_witness_len = output_witness_len; } diff --git a/crates/akita-schedules/src/group_batch.rs b/crates/akita-schedules/src/group_batch.rs index 6b9e32680..25eaf900d 100644 --- a/crates/akita-schedules/src/group_batch.rs +++ b/crates/akita-schedules/src/group_batch.rs @@ -158,6 +158,7 @@ pub(crate) fn multi_group_root_precommitted_groups_for_open_basis( policy: &PlannerPolicy, ring_challenge_config: &dyn Fn(usize) -> Result, log_basis_open: u32, + open_ring_dimension: usize, ) -> Result<(Vec, usize), AkitaError> { let seeds = multi_group_root_precommitted_group_seeds(key, generated_groups, policy)?; let groups = seeds @@ -176,7 +177,7 @@ pub(crate) fn multi_group_root_precommitted_groups_for_open_basis( let mut d_width = 0usize; for group in &groups { d_width = d_width - .checked_add(group.d_segment_width(policy.uniform_ring_dimension)?) + .checked_add(group.d_segment_width(open_ring_dimension)?) .ok_or_else(|| AkitaError::InvalidSetup("multi-group D width overflow".to_string()))?; } Ok((groups, d_width)) diff --git a/crates/akita-schedules/src/lib.rs b/crates/akita-schedules/src/lib.rs index 5135bcf64..92889bdb4 100644 --- a/crates/akita-schedules/src/lib.rs +++ b/crates/akita-schedules/src/lib.rs @@ -24,17 +24,19 @@ pub use resolve::{ ResolvedScheduleRow, }; pub use runtime::{ - default_sis_security_policy, PlannerCostModelId, PlannerPolicy, RuntimeSchedulePolicy, - SelectionPolicyId, + default_sis_security_policy, PlannerCostModelId, PlannerPolicy, RingDimensionScheduleMode, + RuntimeSchedulePolicy, SelectionPolicyId, ADAPTIVE_SEARCH_LEVELS, }; /// Shared schedule-construction primitives used by offline search and generated-row replay. #[doc(hidden)] pub mod planner_support { - pub use crate::candidate::{projected_collision_role_price, sis_key_at_dimension}; + pub use crate::candidate::{ + projected_collision_role_price, sis_key_at_dimension, RingDimensionCandidate, + }; pub use crate::runtime::{ grouped_segment_rings, materialize_candidate_schedule, planned_next_witness_len, stage3_payload_bytes_for_successor, validate_policy, CandidateFoldStep, - CandidateTerminalResponse, + CandidateTerminalResponse, MAX_RECURSION_DEPTH, }; } diff --git a/crates/akita-schedules/src/runtime.rs b/crates/akita-schedules/src/runtime.rs index 576b38d1e..11cce2624 100644 --- a/crates/akita-schedules/src/runtime.rs +++ b/crates/akita-schedules/src/runtime.rs @@ -4,7 +4,7 @@ use akita_field::AkitaError; use akita_types::{ ChunkedWitnessCfg, CommitmentRingDims, CommittedGroupParams, DecompositionParams, FoldSchedule, FoldScheduleEstimate, PlannedFoldSchedule, PolynomialGroupLayout, RecursiveFoldParams, - RecursiveFoldStep, RootFinalGroupParams, RootFoldParams, RootFoldStep, + RecursiveFoldStep, RingRole, RootFinalGroupParams, RootFoldParams, RootFoldStep, RootPrecommittedGroupParams, SisModulusProfileId, SisSecurityPolicyId, TerminalFoldParams, TerminalFoldStep, TerminalResponseShape, WitnessLayout, WitnessPartition, DEFAULT_SIS_SECURITY_POLICY, @@ -48,13 +48,14 @@ impl SelectionPolicyId { /// Canonical selection objective for one schedule policy shape. pub fn for_policy( recursive_setup_planning: bool, - uniform_ring_dimension: usize, - ring_dimension_candidates: &[CommitmentRingDims], + ring_dimension_schedule_mode: RingDimensionScheduleMode, ) -> Self { if recursive_setup_planning { Self::MinFirstDirectSetupThenPayload - } else if ring_dimension_candidates != [CommitmentRingDims::uniform(uniform_ring_dimension)] - { + } else if matches!( + ring_dimension_schedule_mode, + RingDimensionScheduleMode::AdaptiveDimension { .. } + ) { Self::MinSetupMatrixFieldElementsThenProofPayload } else { Self::MinEstimatedProofPayload @@ -82,6 +83,47 @@ impl SelectionPolicyId { } } +/// Catalog-bound ring-dimension schedule policy. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum RingDimensionScheduleMode { + /// Use one uniform A/B/D dimension from root through terminal. + UniformDimension { ring_dimension: usize }, + /// Search A over a bounded prefix, derive B/D by minimum rank, then use a uniform suffix. + AdaptiveDimension { + num_search_levels: usize, + uniform_suffix_dimension: usize, + potential_a_dimensions: &'static [usize], + potential_b_dimensions: &'static [usize], + potential_d_dimensions: &'static [usize], + }, +} + +/// Number of leading fold levels covered by the audited adaptive search. +pub const ADAPTIVE_SEARCH_LEVELS: usize = 2; + +impl RingDimensionScheduleMode { + #[must_use] + pub const fn uniform_dimensions(self) -> Option { + match self { + Self::UniformDimension { ring_dimension } => { + Some(CommitmentRingDims::uniform(ring_dimension)) + } + Self::AdaptiveDimension { .. } => None, + } + } + + #[must_use] + pub const fn potential_a_dimensions(self) -> &'static [usize] { + match self { + Self::UniformDimension { .. } => &[], + Self::AdaptiveDimension { + potential_a_dimensions, + .. + } => potential_a_dimensions, + } + } +} + /// Runtime schedule validation policy. /// /// The compatibility name stays `PlannerPolicy` during the migration because @@ -97,13 +139,12 @@ pub struct PlannerPolicy { pub min_offloaded_witness_contraction: usize, /// Ring dimension used when the planner is restricted to a uniform domain. pub uniform_ring_dimension: usize, - /// A-matrix ring dimension used to commit offloaded setup prefixes. + /// Default/ceiling A-matrix dimension for setup-prefix catalog identity. + /// Adaptive schedules derive each actual prefix A dimension from its + /// consuming fold. pub setup_prefix_inner_ring_dimension: usize, - /// Canonically ordered A/B/D tuples admitted by offline schedule search. - /// - /// Generated catalog identity binds this complete domain, including tuples - /// that do not win any emitted row. - pub ring_dimension_candidates: &'static [CommitmentRingDims], + /// Uniform or bounded-adaptive ring-dimension schedule policy. + pub ring_dimension_schedule_mode: RingDimensionScheduleMode, pub decomposition: DecompositionParams, pub sis_modulus_profile: SisModulusProfileId, pub sis_security_policy: SisSecurityPolicyId, @@ -165,8 +206,7 @@ impl PlannerPolicy { recursive_setup_planning: false, selection_policy: SelectionPolicyId::for_policy( false, - self.uniform_ring_dimension, - self.ring_dimension_candidates, + self.ring_dimension_schedule_mode, ), ..self } @@ -210,17 +250,22 @@ impl PlannerPolicy { } } -/// Suffix-DP depth cap carried into runtime validation for chunk policy bounds. -pub(crate) const MAX_RECURSION_DEPTH: usize = 12; +/// Suffix-DP depth cap shared by planner search and runtime policy validation. +pub const MAX_RECURSION_DEPTH: usize = 12; /// Validate runtime policy values used by schedule expansion and validation. pub fn validate_policy(policy: &PlannerPolicy) -> Result<(), AkitaError> { policy.challenge_field_bits()?; - validate_ring_dimension_candidates(policy)?; + if !akita_types::sis::SUPPORTED_SIS_SECURITY_POLICIES.contains(&policy.sis_security_policy) { + return Err(AkitaError::InvalidSetup(format!( + "unsupported SIS security policy {:?}", + policy.sis_security_policy + ))); + } + validate_ring_dimension_schedule_mode(policy)?; let expected_selection_policy = SelectionPolicyId::for_policy( policy.recursive_setup_planning, - policy.uniform_ring_dimension, - policy.ring_dimension_candidates, + policy.ring_dimension_schedule_mode, ); if policy.selection_policy != expected_selection_policy { return Err(AkitaError::InvalidSetup( @@ -232,18 +277,10 @@ pub fn validate_policy(policy: &PlannerPolicy) -> Result<(), AkitaError> { "explicit setup field budget must be positive".to_string(), )); } - for (label, dimension) in [ - ("uniform", policy.uniform_ring_dimension), - ( - "setup-prefix inner", - policy.setup_prefix_inner_ring_dimension, - ), - ] { - if !dimension.is_power_of_two() { - return Err(AkitaError::InvalidSetup(format!( - "schedule {label} ring dimension must be a nonzero power of two" - ))); - } + if !policy.setup_prefix_inner_ring_dimension.is_power_of_two() { + return Err(AkitaError::InvalidSetup( + "schedule setup-prefix inner ring dimension must be a nonzero power of two".to_string(), + )); } if policy.min_offloaded_witness_contraction == 0 { return Err(AkitaError::InvalidSetup( @@ -260,21 +297,127 @@ pub fn validate_policy(policy: &PlannerPolicy) -> Result<(), AkitaError> { Ok(()) } -fn validate_ring_dimension_candidates(policy: &PlannerPolicy) -> Result<(), AkitaError> { - let candidates = policy.ring_dimension_candidates; - if candidates.is_empty() { - return Err(AkitaError::InvalidSetup( - "ring-dimension candidate domain must be nonempty".to_string(), - )); +fn validate_ring_dimension_schedule_mode(policy: &PlannerPolicy) -> Result<(), AkitaError> { + match policy.ring_dimension_schedule_mode { + RingDimensionScheduleMode::UniformDimension { ring_dimension } => { + if ring_dimension != policy.uniform_ring_dimension { + return Err(AkitaError::InvalidSetup(format!( + "uniform schedule D{ring_dimension} must equal configured D{}", + policy.uniform_ring_dimension + ))); + } + for role in [RingRole::Inner, RingRole::Outer, RingRole::Opening] { + validate_scheduled_dimension(policy, role, ring_dimension)?; + } + } + RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + } => { + if num_search_levels != ADAPTIVE_SEARCH_LEVELS { + return Err(AkitaError::InvalidSetup(format!( + "adaptive search currently requires exactly {ADAPTIVE_SEARCH_LEVELS} levels, got {num_search_levels}" + ))); + } + for (role, dimensions) in [ + (RingRole::Inner, potential_a_dimensions), + (RingRole::Outer, potential_b_dimensions), + (RingRole::Opening, potential_d_dimensions), + ] { + validate_dimension_list(policy, role, dimensions)?; + if !dimensions.contains(&uniform_suffix_dimension) { + return Err(AkitaError::InvalidSetup(format!( + "adaptive {} domain must contain suffix D{uniform_suffix_dimension}", + role_name(role) + ))); + } + if dimensions.iter().any(|&d| d < uniform_suffix_dimension) { + return Err(AkitaError::InvalidSetup(format!( + "adaptive {} dimensions must be at least suffix D{uniform_suffix_dimension}", + role_name(role) + ))); + } + } + } + } + Ok(()) +} + +fn role_name(role: RingRole) -> &'static str { + match role { + RingRole::Inner => "A", + RingRole::Outer => "B", + RingRole::Opening => "D", + } +} + +fn sis_role(role: RingRole) -> akita_types::SisMatrixRole { + match role { + RingRole::Inner => akita_types::SisMatrixRole::Inner, + RingRole::Outer => akita_types::SisMatrixRole::Outer, + RingRole::Opening => akita_types::SisMatrixRole::Open, + } +} + +fn validate_scheduled_dimension( + policy: &PlannerPolicy, + role: RingRole, + dimension: usize, +) -> Result<(), AkitaError> { + let tier = akita_types::protocol_dispatch_tier_for_sis_profile(policy.sis_modulus_profile); + if !akita_types::dispatch::role_dim_supported_for_tier(tier, role, dimension) { + return Err(AkitaError::InvalidSetup(format!( + "scheduled {} dimension D{dimension} is unsupported by the {:?} protocol dispatch", + role_name(role), + policy.sis_modulus_profile + ))); + } + let dimension_u32 = u32::try_from(dimension).map_err(|_| { + AkitaError::InvalidSetup(format!( + "scheduled {} dimension D{dimension} exceeds u32", + role_name(role) + )) + })?; + if !akita_types::sis::sis_role_dimension_supported( + sis_role(role), + policy.sis_modulus_profile, + dimension_u32, + ) { + return Err(AkitaError::InvalidSetup(format!( + "scheduled {} dimension D{dimension} has no SIS security-table coverage for {:?}", + role_name(role), + policy.sis_modulus_profile + ))); + } + if role == RingRole::Inner && !akita_types::SUPPORTED_CHALLENGE_RING_DIMS.contains(&dimension) { + return Err(AkitaError::InvalidSetup(format!( + "scheduled A dimension D{dimension} has no production fold-challenge configuration" + ))); } - let key = |dims: CommitmentRingDims| (dims.d_a(), dims.d_b(), dims.d_d()); - for (index, &dims) in candidates.iter().enumerate() { - dims.validate_role_projection()?; - if index > 0 && key(candidates[index - 1]) >= key(dims) { - return Err(AkitaError::InvalidSetup( - "ring-dimension candidate domain must be strictly sorted and duplicate-free" - .to_string(), - )); + Ok(()) +} + +fn validate_dimension_list( + policy: &PlannerPolicy, + role: RingRole, + dimensions: &[usize], +) -> Result<(), AkitaError> { + if dimensions.is_empty() { + return Err(AkitaError::InvalidSetup(format!( + "adaptive {} domain must be nonempty", + role_name(role) + ))); + } + for (index, &dimension) in dimensions.iter().enumerate() { + validate_scheduled_dimension(policy, role, dimension)?; + if index > 0 && dimensions[index - 1] >= dimension { + return Err(AkitaError::InvalidSetup(format!( + "adaptive {} domain must be strictly sorted and duplicate-free", + role_name(role) + ))); } } Ok(()) @@ -475,7 +618,16 @@ pub fn planned_next_witness_len( params: &CommittedGroupParams, final_num_polys: usize, num_chunks: usize, -) -> Result { +) -> Result, AkitaError> { + if !params.precommitted_groups.is_empty() { + return Err(AkitaError::InvalidSetup( + "multi-group root witness sizing must use CommittedGroupParams::output_witness_len" + .to_string(), + )); + } + if !params.compression_sources_supported()? { + return Ok(None); + } let opening_batch = params.opening_layout_for_final_group(PolynomialGroupLayout::new(0, final_num_polys))?; let layout = WitnessLayout::new( @@ -484,10 +636,95 @@ pub fn planned_next_witness_len( num_chunks, akita_types::sis::compute_num_digits_field_width(field_bits, params.log_basis_open), )?; - Ok(layout.live_coeff_len()) + Ok(Some(layout.live_coeff_len())) } /// Convenience policy used by config adapters. pub fn default_sis_security_policy() -> SisSecurityPolicyId { DEFAULT_SIS_SECURITY_POLICY } + +#[cfg(test)] +mod tests { + use super::*; + + const A_DIMENSIONS_WITHOUT_GLOBAL_CARRIER: &[usize] = &[64, 512]; + const SUFFIX_DIMENSIONS: &[usize] = &[64]; + + fn adaptive_policy() -> PlannerPolicy { + PlannerPolicy { + cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, + selection_policy: SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, + setup_field_budget: None, + min_offloaded_witness_contraction: 3, + // This remains the uniform preset candidate. It is deliberately + // smaller than D512 to prove that it is not an adaptive carrier. + uniform_ring_dimension: 64, + setup_prefix_inner_ring_dimension: 64, + ring_dimension_schedule_mode: RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels: 2, + uniform_suffix_dimension: 64, + potential_a_dimensions: A_DIMENSIONS_WITHOUT_GLOBAL_CARRIER, + potential_b_dimensions: SUFFIX_DIMENSIONS, + potential_d_dimensions: SUFFIX_DIMENSIONS, + }, + decomposition: DecompositionParams { + log_basis: 3, + log_commit_bound: 1, + log_open_bound: Some(128), + }, + sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, + sis_security_policy: DEFAULT_SIS_SECURITY_POLICY, + sis_table_digest: akita_types::SisTableDigest::CURRENT, + ring_subfield_norm_bound: 1, + claim_ext_degree: 1, + chal_ext_degree: 1, + basis_range: (3, 6), + witness_chunk: ChunkedWitnessCfg::default(), + recursive_setup_planning: false, + } + } + + #[test] + fn adaptive_dimensions_do_not_require_a_global_carrier() { + let mut policy = adaptive_policy(); + policy.uniform_ring_dimension = 3; + validate_policy(&policy) + .expect("individually supported D512 A must not depend on the uniform-only field"); + } + + #[test] + fn adaptive_dimensions_still_require_role_specific_dispatch_support() { + const UNSUPPORTED_B_DIMENSIONS: &[usize] = &[64, 512]; + let mut policy = adaptive_policy(); + policy.ring_dimension_schedule_mode = RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels: 2, + uniform_suffix_dimension: 64, + potential_a_dimensions: A_DIMENSIONS_WITHOUT_GLOBAL_CARRIER, + potential_b_dimensions: UNSUPPORTED_B_DIMENSIONS, + potential_d_dimensions: SUFFIX_DIMENSIONS, + }; + + let error = validate_policy(&policy).expect_err("fp128 B has no D512 dispatch"); + assert!(error.to_string().contains("scheduled B dimension D512")); + } + + #[test] + fn adaptive_depth_is_limited_to_the_audited_l0_l1_cutover() { + for num_search_levels in [1, 3] { + let mut policy = adaptive_policy(); + policy.ring_dimension_schedule_mode = RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension: 64, + potential_a_dimensions: A_DIMENSIONS_WITHOUT_GLOBAL_CARRIER, + potential_b_dimensions: SUFFIX_DIMENSIONS, + potential_d_dimensions: SUFFIX_DIMENSIONS, + }; + + let error = validate_policy(&policy).expect_err("unsupported adaptive depth"); + assert!(error + .to_string() + .contains("adaptive search currently requires exactly 2 levels")); + } + } +} diff --git a/crates/akita-setup/src/lib.rs b/crates/akita-setup/src/lib.rs index 8635c62da..3b05bb40b 100644 --- a/crates/akita-setup/src/lib.rs +++ b/crates/akita-setup/src/lib.rs @@ -585,7 +585,7 @@ mod tests { use akita_serialization::{AkitaDeserialize, AkitaSerialize}; use akita_types::SetupMatrixCapacity; - type Cfg = fp128::D64Dense; + type Cfg = fp128::Dense; type TestF = fp128::Field; #[test] @@ -617,12 +617,10 @@ mod tests { #[test] fn setup_accepts_field_coupled_presets() { - // The D128 catalog begins at nv=13; the D64 catalog begins at nv=14, - // the first singleton shapes with the required root and suffix folds. - new_prover_setup::(13, 1) - .expect("default fp128 D=128 preset should accept the fp128 field"); - new_prover_setup::(14, 1) - .expect("small-D fp128 preset should accept the default field"); + // The D64 catalog begins at nv=14, the first singleton shape with the + // required root and suffix folds. + new_prover_setup::(14, 1) + .expect("fp128 dense preset should accept the default field"); } #[cfg(feature = "disk-persistence")] diff --git a/crates/akita-types/src/dispatch/mod.rs b/crates/akita-types/src/dispatch/mod.rs index 543e14a4f..7d7f9e689 100644 --- a/crates/akita-types/src/dispatch/mod.rs +++ b/crates/akita-types/src/dispatch/mod.rs @@ -9,6 +9,7 @@ mod policy; use crate::layout::{CommitmentRingDims, RingRole}; +use crate::sis::SisModulusProfileId; use akita_algebra::ntt::tables::{Q32_MODULUS, Q64_MODULUS}; use akita_field::{AkitaError, CanonicalField}; @@ -43,6 +44,23 @@ pub enum ProtocolDispatchSlot { Compression, } +/// Dispatch tier selected by one exact SIS modulus profile. +/// +/// Planner/runtime policies carry the modulus profile rather than a concrete +/// field type, so policy validation uses this mapping to audit candidate ring +/// dimensions against the same role tables used by prover/verifier dispatch. +#[inline] +#[must_use] +pub const fn protocol_dispatch_tier_for_sis_profile( + profile: SisModulusProfileId, +) -> ProtocolRingDispatchTierId { + match profile { + SisModulusProfileId::Q128OffsetA7F7 => ProtocolRingDispatchTierId::Fp128, + SisModulusProfileId::Q64Offset59 => ProtocolRingDispatchTierId::Fp64, + SisModulusProfileId::Q32Offset99 => ProtocolRingDispatchTierId::Fp32, + } +} + /// Canonical field modulus from the canonical representation of `-1`. /// /// Uses the identity: the canonical form of `-1` in `Z_q` is `q - 1`. diff --git a/crates/akita-types/src/lib.rs b/crates/akita-types/src/lib.rs index d036644b6..d42988905 100644 --- a/crates/akita-types/src/lib.rs +++ b/crates/akita-types/src/lib.rs @@ -11,9 +11,9 @@ pub mod dispatch; pub use dispatch::{ compression_ring_dim_supported_for_tier, field_modulus, ntt_max_ring_d, ntt_min_ring_d, ntt_ring_degree_supported_for_field, ntt_ring_degree_supported_for_tier, - outer_opening_min_ring_d, protocol_dispatch_tier, validate_ring_dispatch, - validate_role_dims_for_field, validate_role_dispatch, ProtocolDispatchSlot, - ProtocolRingDispatchTierId, + outer_opening_min_ring_d, protocol_dispatch_tier, protocol_dispatch_tier_for_sis_profile, + validate_ring_dispatch, validate_role_dims_for_field, validate_role_dispatch, + ProtocolDispatchSlot, ProtocolRingDispatchTierId, }; pub mod extension_opening_reduction; pub mod field_reduction; diff --git a/crates/akita-types/src/sis/ajtai_key.rs b/crates/akita-types/src/sis/ajtai_key.rs index d5637063b..19e6d7265 100644 --- a/crates/akita-types/src/sis/ajtai_key.rs +++ b/crates/akita-types/src/sis/ajtai_key.rs @@ -261,6 +261,22 @@ pub const SIS_MATRIX_ROLES: &[SisMatrixRole] = &[ SisMatrixRole::Open, ]; +/// Whether generated SIS security floors cover one role/profile/dimension. +#[must_use] +pub fn sis_role_dimension_supported( + role: SisMatrixRole, + modulus_profile: SisModulusProfileId, + ring_dimension: u32, +) -> bool { + match role { + SisMatrixRole::Inner => { + A_ROLE_RING_DIMS.contains(&ring_dimension) + || (modulus_profile == SisModulusProfileId::Q128OffsetA7F7 && ring_dimension == 512) + } + SisMatrixRole::Outer | SisMatrixRole::Open => BD_ROLE_RING_DIMS.contains(&ring_dimension), + } +} + /// Return whether the exact role cell is part of the canonical coverage. /// /// The function is deliberately role aware. It does not form a product of @@ -272,19 +288,13 @@ pub fn sis_role_cell( ring_dimension: u32, coeff_linf_bound: u128, ) -> Option { - let (dimension_supported, bounds) = match role { - SisMatrixRole::Inner => ( - A_ROLE_RING_DIMS.contains(&ring_dimension) - || (modulus_profile == SisModulusProfileId::Q128OffsetA7F7 - && ring_dimension == 512), - COEFF_LINF_BUCKETS, - ), - SisMatrixRole::Outer | SisMatrixRole::Open => ( - BD_ROLE_RING_DIMS.contains(&ring_dimension), - GADGET_COEFF_LINF_ANCHORS, - ), + let bounds = match role { + SisMatrixRole::Inner => COEFF_LINF_BUCKETS, + SisMatrixRole::Outer | SisMatrixRole::Open => GADGET_COEFF_LINF_ANCHORS, }; - if !dimension_supported || !bounds.contains(&coeff_linf_bound) { + if !sis_role_dimension_supported(role, modulus_profile, ring_dimension) + || !bounds.contains(&coeff_linf_bound) + { return None; } Some(SisRoleCell { diff --git a/crates/akita-types/src/sis/mod.rs b/crates/akita-types/src/sis/mod.rs index 830f60f7a..48c8b7695 100644 --- a/crates/akita-types/src/sis/mod.rs +++ b/crates/akita-types/src/sis/mod.rs @@ -32,11 +32,11 @@ pub mod norm_bound; pub use ajtai_key::{ ceil_coeff_linf_bucket, ceil_supported_linf_bound, min_secure_rank, - sis_table_key_for_linf_bound, InnerCommitMatrixParams, OpenCommitMatrixParams, - OuterCommitMatrixParams, ScalarCutoff, SisMatrixRole, SisModulusProfileId, SisRoleCell, - SisSecurityPolicyId, SisTableDigest, SisTableKey, A_ROLE_RING_DIMS, BD_ROLE_RING_DIMS, - COEFF_LINF_BUCKETS, DEFAULT_SIS_SECURITY_POLICY, GADGET_COEFF_LINF_ANCHORS, SIS_MATRIX_ROLES, - SUPPORTED_SIS_SECURITY_POLICIES, + sis_role_dimension_supported, sis_table_key_for_linf_bound, InnerCommitMatrixParams, + OpenCommitMatrixParams, OuterCommitMatrixParams, ScalarCutoff, SisMatrixRole, + SisModulusProfileId, SisRoleCell, SisSecurityPolicyId, SisTableDigest, SisTableKey, + A_ROLE_RING_DIMS, BD_ROLE_RING_DIMS, COEFF_LINF_BUCKETS, DEFAULT_SIS_SECURITY_POLICY, + GADGET_COEFF_LINF_ANCHORS, SIS_MATRIX_ROLES, SUPPORTED_SIS_SECURITY_POLICIES, }; pub use decomposition_digits::{ balanced_digit_abs_max, compute_num_digits_field_width, decomposed_s_block_ring_count, diff --git a/crates/akita-verifier/Cargo.toml b/crates/akita-verifier/Cargo.toml index d804f54e8..6a5e46910 100644 --- a/crates/akita-verifier/Cargo.toml +++ b/crates/akita-verifier/Cargo.toml @@ -42,8 +42,7 @@ workspace = true [dev-dependencies] akita-config = { version = "0.1.0", path = "../akita-config", default-features = false, features = [ "test-support", - "schedules-fp128-d128-dense", - "schedules-fp128-d64-dense", + "schedules-fp128-dense", ] } criterion = "0.5" diff --git a/crates/akita-verifier/src/protocol/core/terminal_ntt.rs b/crates/akita-verifier/src/protocol/core/terminal_ntt.rs index 19c88c607..f92179619 100644 --- a/crates/akita-verifier/src/protocol/core/terminal_ntt.rs +++ b/crates/akita-verifier/src/protocol/core/terminal_ntt.rs @@ -102,7 +102,7 @@ mod tests { use super::*; use akita_algebra::ntt::ifma52::ifma52_enabled; use akita_algebra::ntt::tables::{Q128_NUM_PRIMES, Q32_NUM_PRIMES}; - use akita_config::{proof_optimized::fp128::D64OneHot, CommitmentConfig}; + use akita_config::{proof_optimized::fp128::OneHot, CommitmentConfig}; use akita_field::{Prime128Offset275 as F, Prime32Offset99 as F32}; use akita_types::{ select_crt_ntt_params, AkitaExpandedSetup, AkitaScheduleLookupKey, AkitaSetupDescriptor, @@ -274,8 +274,8 @@ mod tests { #[test] fn schedule_warm_builds_terminal_cache_once_before_arithmetic() { let group = PolynomialGroupLayout::new(15, 1); - let schedule = D64OneHot::runtime_schedule(AkitaScheduleLookupKey::single(group)) - .expect("D64 schedule"); + let schedule = OneHot::runtime_schedule(AkitaScheduleLookupKey::single(group)) + .expect("adaptive schedule"); let params = &schedule.terminal.params.witness; let prefix_len = params .inner_commit_matrix diff --git a/crates/akita-verifier/src/protocol/evaluation_trace.rs b/crates/akita-verifier/src/protocol/evaluation_trace.rs index e0fc1098f..fe23f03e5 100644 --- a/crates/akita-verifier/src/protocol/evaluation_trace.rs +++ b/crates/akita-verifier/src/protocol/evaluation_trace.rs @@ -338,11 +338,11 @@ mod tests { #[test] fn compact_trace_matches_dense_definition_across_coefficient_blocks() { - type Cfg = fp128::D128Dense; + type Cfg = fp128::Dense; type F = fp128::Field; type E = F; const D: usize = Cfg::D; - const NUM_VARIABLES: usize = 20; + const NUM_VARIABLES: usize = 16; let opening_batch = OpeningClaimsLayout::new(NUM_VARIABLES, 2).expect("two-claim opening group"); diff --git a/crates/akita-verifier/src/stages/stage3.rs b/crates/akita-verifier/src/stages/stage3.rs index f8cb77104..41efd99be 100644 --- a/crates/akita-verifier/src/stages/stage3.rs +++ b/crates/akita-verifier/src/stages/stage3.rs @@ -290,7 +290,7 @@ where #[cfg(test)] mod tests { use super::*; - use akita_config::{committed_group_params, proof_optimized::fp128::D64Dense}; + use akita_config::{committed_group_params, proof_optimized::fp128::Dense}; use akita_field::Prime128OffsetA7F7; use akita_transcript::AkitaTranscript; use akita_types::{ @@ -345,10 +345,14 @@ mod tests { #[test] fn offloaded_setup_ignores_shared_matrix_divisibility() { - let level_params = - committed_group_params::(&PolynomialGroupLayout::singleton(16)) - .expect("level parameters"); - let natural_field_len = RING_D + 1; + let level_params = committed_group_params::(&PolynomialGroupLayout::singleton(16)) + .expect("level parameters"); + let natural_field_len = level_params + .inner_commit_matrix + .ring_dimension() + .div_ceil(2) + + 1; + let expected_setup_eval_len = padded_setup_prefix_len(natural_field_len) / RING_D; let (setup, offloaded_params) = verifier_setup_with_unaligned_matrix(level_params.clone(), natural_field_len); assert!(!setup @@ -367,7 +371,7 @@ mod tests { &mut offloaded_transcript, ) .expect("offloaded setup uses the registered prefix"), - 2, + expected_setup_eval_len, ); let mut direct_transcript = AkitaTranscript::::new(b"test/direct-stage3"); diff --git a/profile/akita-recursion/README.md b/profile/akita-recursion/README.md index 3b6db9aed..7df24d1a2 100644 --- a/profile/akita-recursion/README.md +++ b/profile/akita-recursion/README.md @@ -19,7 +19,7 @@ RISC-V targets and applies Jolt's `[patch.crates-io]` overrides for | `host/` | bin | Compiles the guest, runs Jolt prove/verify, prints cycle counts. | | `guest/` | bin | `#[jolt::provable]` RISC-V program that runs the Akita verifier. | -## Quick start (`nv=32`, OneHot D=64 — canonical target) +## Quick start (`nv=32`, adaptive OneHot — canonical target) You need the [Jolt CLI](https://github.com/a16z/jolt) installed (`cargo install --path .` from a clone of `jolt` at the same rev this @@ -42,9 +42,9 @@ AKITA_NUM_VARS=32 \ ./target/release/akita-recursion-artifact # 3. Compile the guest to RISC-V, emulate it, and report cycle markers. -# Trace-only (no Jolt prover) because at nv=32 the trace is on the order of -# ~8 G cycles at D=64, still above the current `max_trace_length = 4 G` in -# `#[jolt::provable]` attribute (see "Open follow-ups" below). +# Start with trace-only (no Jolt prover) when measuring a new adaptive +# schedule. Confirm the trace fits the current `max_trace_length = 4 G` +# before running the full prover (see "Open follow-ups" below). # `--trace-output /dev/null` keeps the raw trace bytes off disk while # preserving the cycle-marker output. ZEROOS_GUEST_RUSTFLAGS=-Zunstable-options \ @@ -54,14 +54,13 @@ ZEROOS_GUEST_RUSTFLAGS=-Zunstable-options \ --input target/akita_recursion_inputs_nv32.bin ``` -Expected output (Apple Silicon laptop, ≈ 22 min wall clock; D=64 OneHot, -order-of-magnitude — rerun `--trace-only` for fresh numbers): +Expected output shape (rerun `--trace-only` for current adaptive numbers): ``` "deserialize_input": … (dominated by expanded verifier-setup decode) "transcript_init": … "akita_verify": … -trace length: ~8 G cycles +trace length: … trace done ``` @@ -71,10 +70,9 @@ that lives inside the blob; the proof itself is a tiny fraction. ## Running the full prove pipeline The full pipeline (Dory preprocessing → Jolt prove → Jolt verify) runs -end-to-end at smaller arities where the trace fits under -`max_trace_length = 4 G`. Drop the `AKITA_NUM_VARS` override down (e.g. -`AKITA_NUM_VARS=20` produces a ≈ 4 MiB blob and a ≈ 150 M-cycle trace) -and remove `--trace-only`: +end-to-end at arities where the trace fits under `max_trace_length = 4 G`. +Start with `AKITA_NUM_VARS=20`, measure it with `--trace-only`, and then remove +`--trace-only` once the trace bound is confirmed: ```bash AKITA_NUM_VARS=20 ./target/release/akita-recursion-artifact @@ -134,7 +132,7 @@ rm -rf /tmp/akita-recursion-targets /tmp/jolt-guest-targets ## How it works -1. **`artifact`** runs `AkitaCommitmentScheme::<64, fp128::D64OneHot>` → +1. **`artifact`** runs `AkitaCommitmentScheme::` → `setup_prover` → `commit` → `batched_prove` over a synthetic OneHot polynomial, sanity-verifies on the host, and serializes `(transcript_domain, num_vars, opening_point, opening, commitment, @@ -167,12 +165,18 @@ rm -rf /tmp/akita-recursion-targets /tmp/jolt-guest-targets feature list to `guest`. A production recursion circuit must use strict setup validation or bind an externally checked setup commitment. -## Why we pin D=64 (not D=32) for Jolt cycle benches +## Adaptive dimension pin and historical D64 measurements -A natural surprise: a smaller ring `D` can make on-CPU proofs smaller, but -**D=32 is not a valid A-role fold degree** (`d_a ≥ 64`) after the ring-dim -cutover, and historical D=32 Jolt traces were **more** expensive than D=64 at -equal `num_vars`. Three compounding effects explained the old D=32 penalty: +The artifact, host, and guest share `D = fp128::OneHot::D = 256`, the adaptive +preset's root envelope. The generated `nv=20` and `nv=32` scalar rows both use +A=D256 at the root and may transition to smaller per-level dimensions. The +artifact rejects any requested arity whose selected root A dimension does not +match this Jolt monomorphization. + +Historical D64 measurements remain useful context, but they do not describe +the current adaptive binary. D32 is not a valid A-role fold degree (`d_a ≥ 64`), +and historical D32 Jolt traces were more expensive than fixed D64 at equal +`num_vars`. Three compounding effects explained the old D32 penalty: 1. **More recursion levels.** Folding nv=32 to a tractable terminal takes 6 levels at D=64 vs 7 at D=32. Each level adds a full @@ -187,11 +191,11 @@ equal `num_vars`. Three compounding effects explained the old D=32 penalty: cycle. Smaller-D work doesn't compress into fewer RV64 instructions. -For reference: OneHot **D=64** `nv=32` produces a trace on the order of -**~8 G cycles** (~30% cheaper inside Jolt than the retired D=32 configuration) -while remaining the production fp128 preset. +For historical reference, fixed-D64 OneHot at `nv=32` produced a trace on the +order of 8 G cycles, about 30% cheaper inside Jolt than the retired D32 +configuration. Remeasure before making claims about the adaptive preset. -## Optimization history at `nv=20` (D=64) +## Historical optimization results at `nv=20` (fixed D64) Two guest-level changes landed during bring-up. They live in the git history; numbers measured against the D=64 OneHot configuration are: @@ -212,13 +216,13 @@ size. ## Open follow-ups -1. **Full prove at `nv=32`** on a beefier host. Requires: - - Bumping `max_trace_length` past ~8 G in the `#[jolt::provable]` - attribute (currently 4 G — fine for `nv ≤ 20`, insufficient at - `nv=32`). +1. **Remeasure and run a full adaptive prove at `nv=32`** on a beefier host. + Requires: + - Measuring the adaptive trace and, if necessary, increasing + `max_trace_length` beyond the current 4 G limit. - Server-class memory headroom (guest heap is sized for large nv=32 blobs). - - Expected wall clock at typical zkVM throughput (~500 kHz): - **~6 h+** of proving. + - Estimating wall clock from the newly measured trace rather than the + historical fixed-D64 result. 2. **Make `deserialize_input` cheaper.** At `nv=32` it dominates the trace. Most of that is decoding the expanded verifier-setup matrix. Options: diff --git a/profile/akita-recursion/artifact/src/main.rs b/profile/akita-recursion/artifact/src/main.rs index fe201eede..747929f19 100644 --- a/profile/akita-recursion/artifact/src/main.rs +++ b/profile/akita-recursion/artifact/src/main.rs @@ -1,8 +1,8 @@ //! Generate an Akita verifier-input blob to be consumed by the Jolt guest //! program in `profile/akita-recursion/guest`. //! -//! Mirrors `run_profile_onehot_fp128_d64` from `crates/akita-pcs/examples/profile.rs`: -//! single-poly OneHot polynomial commitment in `D=64` mode at the canonical +//! Mirrors the fp128 adaptive one-hot profile from `crates/akita-pcs/examples/profile.rs`: +//! single-poly OneHot polynomial commitment at the canonical //! `q=2^128-2^32+22537` prime, opened at one random point. After running the //! prover end-to-end we re-run the host verifier as a sanity check, then //! serialize all verifier-side state into one contiguous blob via @@ -10,8 +10,9 @@ //! //! Output paths are controlled via `AKITA_RECURSION_BLOB` (defaults to //! `target/akita_recursion_inputs.bin`). Set `AKITA_NUM_VARS` (default 20) -//! to regenerate at a different polynomial arity. Stick with `D=64 OneHot` -//! so the guest's hard-coded monomorphization can read the blob. +//! to regenerate at a different polynomial arity. The Jolt monomorphization +//! uses the adaptive preset's D256 root envelope; the selected catalog row must +//! use that A dimension. #![allow(missing_docs)] @@ -48,13 +49,13 @@ use tracing_subscriber::EnvFilter; struct Args {} type F = fp128::Field; -const D: usize = 64; -type Cfg = fp128::D64OneHot; +type Cfg = fp128::OneHot; +const D: usize = ::D; type Claim = ::ExtField; type Challenge = ::ExtField; const ONEHOT_K: usize = akita_config::proof_optimized::STANDARD_ONEHOT_CHUNK_SIZE; -const TRANSCRIPT_DOMAIN: &[u8] = b"akita-recursion/onehot-d64"; +const TRANSCRIPT_DOMAIN: &[u8] = b"akita-recursion/onehot"; fn onehot_k_for_num_vars(nv: usize) -> usize { let max_supported_log_k = ONEHOT_K.trailing_zeros() as usize; @@ -238,7 +239,7 @@ fn run() -> Result<(), String> { d = D, onehot_k, prime = %prime, - "generating Akita verifier-input artifact (single-poly OneHot, D=64)" + "generating Akita verifier-input artifact (single-poly adaptive OneHot)" ); let opening_layout = OpeningClaimsLayout::new(nv, 1).expect("singleton opening batch"); @@ -313,13 +314,12 @@ fn run() -> Result<(), String> { let poly_refs: [&OneHotPoly; 1] = [&onehot_poly]; let openings = [opening]; - let schedule_selection = - Cfg::select_schedule_for_profiles(&CommittedGroupBatchProfile { - final_group: *commitment.profile(), - precommitteds: Vec::new(), - }) - .map_err(|err| format!("schedule selection failed: {err}"))? - .selection(); + let schedule_selection = Cfg::select_schedule_for_profiles(&CommittedGroupBatchProfile { + final_group: *commitment.profile(), + precommitteds: Vec::new(), + }) + .map_err(|err| format!("schedule selection failed: {err}"))? + .selection(); let t0 = Instant::now(); let mut prover_transcript = AkitaTranscript::::new(TRANSCRIPT_DOMAIN); diff --git a/profile/akita-recursion/glue/src/lib.rs b/profile/akita-recursion/glue/src/lib.rs index 003b64296..d0783b462 100644 --- a/profile/akita-recursion/glue/src/lib.rs +++ b/profile/akita-recursion/glue/src/lib.rs @@ -53,8 +53,9 @@ fn reject_trailing_bytes(rest: &[u8]) -> Result<(), SerializationError> { /// Bundled verifier inputs that travel from the host to the Jolt guest. /// -/// `D` is the cyclotomic ring dimension picked by the host config. The -/// guest must use the same `D` to decode `commitment`. +/// `D` is the cyclotomic root-envelope dimension pinned by the host config. +/// The guest must use the same value to reject blobs built for a different +/// verifier monomorphization; per-level dimensions remain schedule-owned. #[derive(Debug, Clone, PartialEq, Eq)] pub struct AkitaJoltInputs { /// Domain label both prover and verifier transcripts were initialized with. @@ -75,7 +76,7 @@ pub struct AkitaJoltInputs { /// reconstructing a `Schedule` first. pub proof_shape: AkitaBatchedProofShape, /// The Akita batched proof itself. The extension field collapses to `F` - /// for the fp128 D64OneHot profile (`EXT_DEGREE == 1`). + /// for the fp128 OneHot profile (`EXT_DEGREE == 1`). pub proof: AkitaBatchedProof, } @@ -303,8 +304,12 @@ where fn decode_seed_and_matrix( rest: &mut &[u8], ) -> Result<(AkitaSetupDescriptor, FlatMatrix), SerializationError> { - let seed = - AkitaSetupDescriptor::deserialize_with_mode(&mut *rest, BLOB_COMPRESS, BLOB_VALIDATE, &())?; + let seed = AkitaSetupDescriptor::deserialize_with_mode( + &mut *rest, + BLOB_COMPRESS, + BLOB_VALIDATE, + &(), + )?; let matrix_fields = seed.num_field_elements; if matrix_fields > MAX_GENERIC_SETUP_DECODE_FIELD_ELEMENTS { return Err(SerializationError::LengthLimitExceeded { diff --git a/profile/akita-recursion/guest/Cargo.toml b/profile/akita-recursion/guest/Cargo.toml index c2113d0ef..c103ea052 100644 --- a/profile/akita-recursion/guest/Cargo.toml +++ b/profile/akita-recursion/guest/Cargo.toml @@ -35,7 +35,9 @@ trusted-benchmark-artifact = ["akita-recursion-glue/trusted-benchmark-artifact"] # resolve the same way as in the upstream Jolt examples. jolt = { package = "jolt-sdk", git = "https://github.com/a16z/jolt", rev = "2509bdcea9bb3e8978bb578380383ef06dbbada7", default-features = false } akita-recursion-glue = { path = "../glue" } -akita-config = { path = "../../../crates/akita-config", default-features = false } +akita-config = { path = "../../../crates/akita-config", default-features = false, features = [ + "schedules-fp128-onehot", +] } akita-field = { path = "../../../crates/akita-field", default-features = false } akita-transcript = { path = "../../../crates/akita-transcript" } akita-types = { path = "../../../crates/akita-types" } diff --git a/profile/akita-recursion/guest/src/lib.rs b/profile/akita-recursion/guest/src/lib.rs index f363b7848..3720d6736 100644 --- a/profile/akita-recursion/guest/src/lib.rs +++ b/profile/akita-recursion/guest/src/lib.rs @@ -29,8 +29,8 @@ use akita_verifier::batched_verify; use jolt::{end_cycle_tracking, start_cycle_tracking}; type F = fp128::Field; -const D: usize = 64; -type Cfg = fp128::D64OneHot; +type Cfg = fp128::OneHot; +const D: usize = ::D; fn verification_status(result: Result<(), AkitaError>) -> u32 { match result { @@ -39,14 +39,8 @@ fn verification_status(result: Result<(), AkitaError>) -> u32 { } } -const _: () = { - // Hard-fail at compile time if the guest monomorphization drifts away from - // the config and host artifact generator (`../artifact/src/main.rs`). - assert!(D == ::D); -}; - -// Memory limits sized for the Akita verifier with `D=64 OneHot`. Blob size -// scales with `nv` (≈4 MiB at nv=20; tens-to-hundreds of MiB at nv=32). +// Memory limits sized for the adaptive fp128 OneHot verifier. Blob size +// scales with `nv` (≈2.6 MiB at nv=20; tens-to-hundreds of MiB at nv=32). // We give: // - `max_input_size` = 768 MiB so large nv blobs fit with headroom. // Keep this literal equal to diff --git a/profile/akita-recursion/host/Cargo.toml b/profile/akita-recursion/host/Cargo.toml index 46f2c6058..10675c9da 100644 --- a/profile/akita-recursion/host/Cargo.toml +++ b/profile/akita-recursion/host/Cargo.toml @@ -30,7 +30,9 @@ guest = { package = "akita-recursion-guest", path = "../guest", features = [ "benchmark-artifact", ] } akita-recursion-glue = { path = "../glue" } -akita-config = { path = "../../../crates/akita-config", default-features = false } +akita-config = { path = "../../../crates/akita-config", default-features = false, features = [ + "schedules-fp128-onehot", +] } akita-transcript = { path = "../../../crates/akita-transcript" } akita-types = { path = "../../../crates/akita-types" } akita-verifier = { path = "../../../crates/akita-verifier", default-features = false } diff --git a/profile/akita-recursion/host/src/main.rs b/profile/akita-recursion/host/src/main.rs index 32471c093..c890ddf5d 100644 --- a/profile/akita-recursion/host/src/main.rs +++ b/profile/akita-recursion/host/src/main.rs @@ -29,12 +29,8 @@ use tracing_subscriber::EnvFilter; const TRUSTED_BENCHMARK_ARTIFACT_ENV: &str = "AKITA_RECURSION_TRUSTED_BENCHMARK_ARTIFACT"; type F = fp128::Field; -const D: usize = 64; -type Cfg = fp128::D64OneHot; - -const _: () = { - assert!(D == ::D); -}; +type Cfg = fp128::OneHot; +const D: usize = ::D; #[derive(Debug, Parser)] #[command( diff --git a/scripts/check_profile_ci_features.sh b/scripts/check_profile_ci_features.sh index 05a9a88f7..c444f7538 100755 --- a/scripts/check_profile_ci_features.sh +++ b/scripts/check_profile_ci_features.sh @@ -19,14 +19,14 @@ pcs = repo / "crates/akita-pcs/Cargo.toml" MODE_FEATURE = { "onehot_fp32_d128": "schedules-fp32-d128-onehot", "onehot_fp64_d128": "schedules-fp64-d128-onehot", - "dense_fp128_d64": "schedules-fp128-d64-dense", - "onehot_fp128_d64": "schedules-fp128-d64-onehot", - "onehot_fp128_mixed_dim": "schedules-fp128-mixed-dim-onehot", - "onehot_fp128_d64_multi_group_recursive": "schedules-fp128-d64-onehot-recursive", - "onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2": "schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2", - "onehot_fp128_d64_multi_chunk_w8r2": "schedules-fp128-d64-onehot-multi-chunk", - "onehot_fp128_d64_multi_chunk_w2r2": "schedules-fp128-d64-onehot-multi-chunk-w2r2", - "onehot_fp128_d64_multi_chunk_w4r2": "schedules-fp128-d64-onehot-multi-chunk-w4r2", + "dense_fp128": "schedules-fp128-dense", + "onehot_fp128": "schedules-fp128-onehot", + "onehot_fp128_multi_group": "schedules-fp128-onehot", + "onehot_fp128_multi_group_recursive": "schedules-fp128-onehot-recursive", + "onehot_fp128_multi_group_recursive_multi_chunk_w8r2": "schedules-fp128-onehot-recursive-multi-chunk-w8r2", + "onehot_fp128_multi_chunk_w8r2": "schedules-fp128-onehot-multi-chunk", + "onehot_fp128_multi_chunk_w2r2": "schedules-fp128-onehot-multi-chunk-w2r2", + "onehot_fp128_multi_chunk_w4r2": "schedules-fp128-onehot-multi-chunk-w4r2", } MODE_NUM_POLYS = {mode: {1, 4} for mode in MODE_FEATURE} diff --git a/scripts/profile_bench_report.py b/scripts/profile_bench_report.py index 0feb6d989..119566f66 100644 --- a/scripts/profile_bench_report.py +++ b/scripts/profile_bench_report.py @@ -88,28 +88,29 @@ class CaseMetadata: # (`akita_config::generated_families::ALL_GENERATED_FAMILIES`). Modes outside # this map still render via the `case_metadata` fallback below. CASE_METADATA: dict[str, CaseMetadata] = { - # fp128 ships dense + one-hot at D128 and one-hot at D64. - "dense_fp128_d128": CaseMetadata("fp128", "dense", "dense", "D128"), - "onehot_fp128_d64": CaseMetadata("fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64"), - "onehot_fp128_mixed_dim": CaseMetadata( + # Direct fp128 one-hot and dense use adaptive generated schedules. + "onehot_fp128": CaseMetadata( "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "mixed D256 to D64" ), - "onehot_fp128_d64_multi_group_recursive": CaseMetadata( - "fp128", "onehot", "multi-group one-hot", "D64 recursive multi-group" + "dense_fp128": CaseMetadata("fp128", "dense", "dense", "mixed D256 to D64"), + "onehot_fp128_multi_group": CaseMetadata( + "fp128", "onehot", "multi-group one-hot", "multi-group" ), - "onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2": CaseMetadata( - "fp128", "onehot", "multi-group one-hot", "D64 recursive multi-group W8R2" + "onehot_fp128_multi_group_recursive": CaseMetadata( + "fp128", "onehot", "multi-group one-hot", "adaptive recursive multi-group" ), - "onehot_fp128_d64_multi_chunk_w8r2": CaseMetadata( - "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64 multi-chunk W8R2" + "onehot_fp128_multi_group_recursive_multi_chunk_w8r2": CaseMetadata( + "fp128", "onehot", "multi-group one-hot", "adaptive recursive multi-group W8R2" ), - "onehot_fp128_d64_multi_chunk_w2r2": CaseMetadata( - "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64 multi-chunk W2R2" + "onehot_fp128_multi_chunk_w8r2": CaseMetadata( + "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "multi-chunk W8R2" ), - "onehot_fp128_d64_multi_chunk_w4r2": CaseMetadata( - "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64 multi-chunk W4R2" + "onehot_fp128_multi_chunk_w2r2": CaseMetadata( + "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "multi-chunk W2R2" + ), + "onehot_fp128_multi_chunk_w4r2": CaseMetadata( + "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "multi-chunk W4R2" ), - "onehot_fp128_d128": CaseMetadata("fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D128"), # Small fields fold securely only at D128/D256 under honest pricing; fp32 # ships no dense family. "onehot_fp32_d128": CaseMetadata("fp32", "onehot", ONEHOT_WORKLOAD_LABEL, "D128"), @@ -156,7 +157,7 @@ def parse_args() -> argparse.Namespace: run_parser.add_argument( "--output-dir", required=True, help="Directory where logs and summary.json are written." ) - run_parser.add_argument("--mode", default="onehot_fp128_d64", help="Benchmark mode.") + run_parser.add_argument("--mode", default="onehot_fp128", help="Benchmark mode.") run_parser.add_argument("--num-vars", type=int, default=32, help="Number of variables.") run_parser.add_argument( "--num-polys", @@ -245,7 +246,7 @@ def parse_args() -> argparse.Namespace: failure_parser.add_argument( "--output-dir", required=True, help="Directory where summary files are written." ) - failure_parser.add_argument("--mode", default="onehot_fp128_d64", help="Benchmark mode.") + failure_parser.add_argument("--mode", default="onehot_fp128", help="Benchmark mode.") failure_parser.add_argument("--num-vars", type=int, default=32, help="Number of variables.") failure_parser.add_argument( "--num-polys", @@ -1704,10 +1705,10 @@ def field_family_sort_key(case: dict[str, object]) -> int: def config_variant_token(config: object) -> str: - """Camel-case variant tag from the config string, dropping the leading ring - dimension and any `recursive` word. The setup-contribution mode has its own - report column, so recursion is not encoded in the workload name.""" + """Render non-dimension topology tags while hiding dimension policy names.""" remainder = re.sub(r"^\s*D\d+\s*", "", str(config), flags=re.IGNORECASE) + if re.fullmatch(r"mixed\s+D\d+\s+to\s+D\d+", remainder, flags=re.IGNORECASE): + return "" tokens: list[str] = [] for word in remainder.split(): if word.lower() == "recursive": @@ -1719,24 +1720,8 @@ def config_variant_token(config: object) -> str: return "".join(tokens) -def ring_dim_segment(summary: dict[str, object]) -> str | None: - """Render the ring-dimension segment. A/B/D are equal in every current - schedule, so collapse to `D=`; keep a defensive per-role form so a future - mismatch is never silently hidden.""" - planned_levels = summary.get("planned_levels") - if isinstance(planned_levels, list) and planned_levels: - first = planned_levels[0] - d_a, d_b, d_d = int(first["d_a"]), int(first["d_b"]), int(first["d_d"]) - if d_a == d_b == d_d: - return f"D={d_a}" - return f"D_a={d_a}D_b={d_b}D_d={d_d}" - match = re.match(r"D(\d+)", str(summary.get("config", "")), flags=re.IGNORECASE) - if match: - return f"D={match.group(1)}" - return None - - def human_case_label(summary: dict[str, object]) -> str: + """Render a stable workload label without planner-selected dimensions.""" field_family = str(summary.get("field_family", "field")) bits = field_family_bits(field_family) field_segment = f"Fp{bits}" if bits is not None else field_family @@ -1746,9 +1731,6 @@ def human_case_label(summary: dict[str, object]) -> str: num_polys = int(summary.get("num_polys", 1)) if num_polys > 1: segments.append(f"Batched{num_polys}") - ring_segment = ring_dim_segment(summary) - if ring_segment is not None: - segments.append(ring_segment) variant = config_variant_token(summary.get("config", "")) if variant: segments.append(variant) @@ -2129,7 +2111,7 @@ def validate_case_consistency(summary: dict[str, object]) -> None: # Intentionally no per-level `level_bytes` vs `total_bytes` comparison. # The header-stripped planner estimate is only a conservative upper bound # in *aggregate*: it can over- or under-attribute bytes to any individual - # level (e.g. dense_fp128_d128 nv24 has levels where the runtime proof + # level (e.g. dense_fp128_d64 nv24 has levels where the runtime proof # exceeds the per-level estimate while the total stays under it). The # total-overcount invariant is asserted in the profile binary itself # (`ACCEPTED_PLANNER_PROOF_SIZE_OVERCOUNT_BYTES` in diff --git a/scripts/profile_trace_spans.py b/scripts/profile_trace_spans.py index a5dabfb45..86a85ede5 100644 --- a/scripts/profile_trace_spans.py +++ b/scripts/profile_trace_spans.py @@ -13,8 +13,7 @@ DEFAULT_PATTERN = ( r"eor|root_extension|extension_opening|SparseExtensionOpening|" - r"dense_extension_reduction|fused_fold|tensor_packed_sparse|" - r"onehot_tensor_extension" + r"dense_extension_reduction|fused_fold" ) diff --git a/scripts/tests/test_profile_bench_report.py b/scripts/tests/test_profile_bench_report.py index 60e6d9324..f169a8859 100644 --- a/scripts/tests/test_profile_bench_report.py +++ b/scripts/tests/test_profile_bench_report.py @@ -11,7 +11,7 @@ class ProfileBenchReportTests(unittest.TestCase): def test_plan_case_runs_orders_warmups_then_measured(self) -> None: from scripts.profile_bench_report import BenchmarkCaseSpec, ScheduledRun, plan_case_runs - case = BenchmarkCaseSpec(mode="onehot_fp128_d64", num_vars=24, num_polys=1) + case = BenchmarkCaseSpec(mode="onehot_fp128", num_vars=24, num_polys=1) summary_dir = pathlib.Path("/tmp/bench-root") schedule = plan_case_runs("/bin/profile", summary_dir, case, runs=2, warmups=1) @@ -28,7 +28,7 @@ def test_plan_case_runs_orders_warmups_then_measured(self) -> None: def test_interleaved_schedule_alternates_binaries(self) -> None: from scripts.profile_bench_report import BenchmarkCaseSpec, plan_case_runs - case = BenchmarkCaseSpec(mode="onehot_fp128_d64", num_vars=24, num_polys=1) + case = BenchmarkCaseSpec(mode="onehot_fp128", num_vars=24, num_polys=1) binaries = [ ("/bin/pr", pathlib.Path("/tmp/pr")), ("/bin/base", pathlib.Path("/tmp/base")), @@ -59,8 +59,8 @@ def test_configured_cases_rejects_duplicate_case_ids(self) -> None: "Args", (), { - "case": ["onehot_fp128_d64:24:1", "onehot_fp128_d64:24:1"], - "mode": "onehot_fp128_d64", + "case": ["onehot_fp128:24:1", "onehot_fp128:24:1"], + "mode": "onehot_fp128", "num_vars": 24, "num_polys": 1, }, @@ -124,7 +124,7 @@ def test_compact_report_renders_terminal_response_component_table(self) -> None: from scripts.profile_bench_report import render_terminal_response_components case = { - "mode": "onehot_fp128_d64", + "mode": "onehot_fp128", "num_vars": 32, "num_polys": 1, "exit_code": 0, @@ -151,11 +151,11 @@ def test_z_fold_encoding_stats_prefers_wire_low_bits(self) -> None: from scripts.profile_bench_report import extract_summary log = ( - 'INFO z fold encoding stats label=onehot_fp128_d64 ' + 'INFO z fold encoding stats label=onehot_fp128 ' 'z_coords=100 witness_linf_cap=4096 rice_low_bits_wire=10 rice_low_bits_cap=12 ' 'bits_per_coord_at_wire=12.5 bits_per_coord_packed=15.0 z_payload_bytes=200\n' ) - summary = extract_summary(log, mode="onehot_fp128_d64", num_vars=24, num_polys=1) + summary = extract_summary(log, mode="onehot_fp128", num_vars=24, num_polys=1) self.assertEqual(summary["z_rice_low_bits_wire"], 10) self.assertEqual(summary["z_rice_low_bits_cap"], 12) self.assertAlmostEqual(summary["z_bits_per_coord_golomb"], 12.5) @@ -164,12 +164,12 @@ def test_setup_size_parses_flat_field_count(self) -> None: from scripts.profile_bench_report import extract_summary log = ( - " INFO setup sizes label=onehot_fp128_d64 " + " INFO setup sizes label=onehot_fp128 " "num_setup_field_elements=4096 setup_vector_bytes=65536 " "setup_ntt_cache_bytes=131072\n" ) - summary = extract_summary(log, "onehot_fp128_d64", 24, 1) + summary = extract_summary(log, "onehot_fp128", 24, 1) self.assertEqual(summary["num_setup_field_elements"], 4096) @@ -177,12 +177,12 @@ def test_setup_size_converts_merge_base_ring_count_to_flat_fields(self) -> None: from scripts.profile_bench_report import extract_summary log = ( - " INFO setup sizes label=onehot_fp128_d64 " + " INFO setup sizes label=onehot_fp128 " "setup_ring_elements=64 setup_vector_bytes=65536 " "setup_ntt_cache_bytes=131072\n" ) - summary = extract_summary(log, "onehot_fp128_d64", 24, 1) + summary = extract_summary(log, "onehot_fp128", 24, 1) self.assertEqual(summary["num_setup_field_elements"], 4096) @@ -190,7 +190,7 @@ def test_planned_fold_level_parses_physical_geometry(self) -> None: from scripts.profile_bench_report import extract_summary log = ( - 'INFO planned fold level label=onehot_fp128_d64 level=0 d=64 d_a=64 d_b=32 d_d=16 ' + 'INFO planned fold level label=onehot_fp128 level=0 d=64 d_a=64 d_b=32 d_d=16 ' 'n_a=2 n_b=3 n_d=4 ' 'challenge_l1_mass=8 log_basis=5 position_index_bits=7 block_index_bits=3 ' 'num_live_ring_elements_per_claim=768 num_live_blocks=6 block_index_domain_size=8 ' @@ -198,7 +198,7 @@ def test_planned_fold_level_parses_physical_geometry(self) -> None: 'delta_fold=6 current_w_len=1024 next_w_len=2048 level_bytes=4096\n' ) - summary = extract_summary(log, mode="onehot_fp128_d64", num_vars=24, num_polys=1) + summary = extract_summary(log, mode="onehot_fp128", num_vars=24, num_polys=1) self.assertEqual( summary["planned_levels"][0], @@ -240,7 +240,7 @@ def test_planned_fold_level_parses_typed_schedule_field_names(self) -> None: # `input_witness_len`/`output_witness_len`, dropped `level_bytes`, and # now emits `current_w_len` as a group breakdown plus setup-prefix sizes. log = ( - 'INFO planned fold level label=onehot_fp128_d64 level=0 d=64 d_a=64 d_b=32 d_d=16 ' + 'INFO planned fold level label=onehot_fp128 level=0 d=64 d_a=64 d_b=32 d_d=16 ' 'n_a=2 n_b=3 n_d=4 ' 'challenge_l1_mass=8 log_basis=5 position_index_bits=7 block_index_bits=3 ' 'num_live_ring_elements_per_claim=768 num_live_blocks=6 block_index_domain_size=8 ' @@ -250,7 +250,7 @@ def test_planned_fold_level_parses_typed_schedule_field_names(self) -> None: 'setup_prefix_natural_field_elements=100 setup_prefix_padded_field_elements=128\n' ) - summary = extract_summary(log, mode="onehot_fp128_d64", num_vars=24, num_polys=1) + summary = extract_summary(log, mode="onehot_fp128", num_vars=24, num_polys=1) level = summary["planned_levels"][0] self.assertEqual( @@ -270,13 +270,13 @@ def test_planned_fold_level_normalizes_merge_base_geometry(self) -> None: from scripts.profile_bench_report import extract_summary log = ( - 'INFO planned fold level label=onehot_fp128_d64 level=0 d=64 n_a=2 n_b=3 n_d=4 ' + 'INFO planned fold level label=onehot_fp128 level=0 d=64 n_a=2 n_b=3 n_d=4 ' 'challenge_l1_mass=8 log_basis=5 m_vars=7 r_vars=3 ' 'num_blocks=8 block_len=2 delta_commit=4 delta_open=5 ' 'delta_fold=6 current_w_len=1024 next_w_len=2048 level_bytes=4096\n' ) - summary = extract_summary(log, mode="onehot_fp128_d64", num_vars=24, num_polys=1) + summary = extract_summary(log, mode="onehot_fp128", num_vars=24, num_polys=1) level = summary["planned_levels"][0] self.assertEqual(level["position_index_bits"], 7) @@ -291,13 +291,13 @@ def test_planned_fold_level_normalizes_position_bits_merge_base_geometry(self) - from scripts.profile_bench_report import extract_summary log = ( - 'INFO planned fold level label=onehot_fp128_d64 level=0 d=64 n_a=2 n_b=3 n_d=4 ' + 'INFO planned fold level label=onehot_fp128 level=0 d=64 n_a=2 n_b=3 n_d=4 ' 'challenge_l1_mass=8 log_basis=5 position_bits=7 block_bits=3 ' 'num_blocks=8 block_len=128 delta_commit=4 delta_open=5 ' 'delta_fold=6 current_w_len=1024 next_w_len=2048 level_bytes=4096\n' ) - summary = extract_summary(log, mode="onehot_fp128_d64", num_vars=24, num_polys=1) + summary = extract_summary(log, mode="onehot_fp128", num_vars=24, num_polys=1) level = summary["planned_levels"][0] self.assertEqual(level["position_index_bits"], 7) @@ -309,7 +309,7 @@ def test_rendered_schedule_uses_names_and_main_deltas(self) -> None: from scripts.profile_bench_report import extract_summary, render_planned_levels current_log = ( - 'INFO planned fold level label=onehot_fp128_d64 level=0 d=64 d_a=64 d_b=32 d_d=16 ' + 'INFO planned fold level label=onehot_fp128 level=0 d=64 d_a=64 d_b=32 d_d=16 ' 'n_a=4 n_b=6 n_d=8 challenge_l1_mass=16 log_basis=6 position_index_bits=7 ' 'block_index_bits=3 num_live_ring_elements_per_claim=768 num_live_blocks=6 ' 'block_index_domain_size=8 num_positions_per_block=128 delta_commit=4 delta_open=5 ' @@ -318,8 +318,8 @@ def test_rendered_schedule_uses_names_and_main_deltas(self) -> None: baseline_log = current_log.replace("n_a=4", "n_a=2").replace( "level_bytes=4096", "level_bytes=2048" ) - current = extract_summary(current_log, "onehot_fp128_d64", 24, 1)["planned_levels"] - baseline = extract_summary(baseline_log, "onehot_fp128_d64", 24, 1)["planned_levels"] + current = extract_summary(current_log, "onehot_fp128", 24, 1)["planned_levels"] + baseline = extract_summary(baseline_log, "onehot_fp128", 24, 1)["planned_levels"] output = io.StringIO() with contextlib.redirect_stdout(output): @@ -341,12 +341,12 @@ def test_proof_breakdown_marks_absent_components(self) -> None: ) log = ( - 'INFO proof fold level label=onehot_fp128_d64 level=0 d=64 total_bytes=20 ' + 'INFO proof fold level label=onehot_fp128 level=0 d=64 total_bytes=20 ' 'fold_grind_nonce_bytes=4 grind_nonce=3 grind_attempts=4 ' 'stage1_range_image_evaluation_bytes=16 ' 'root_variant=terminal\n' ) - levels = extract_summary(log, "onehot_fp128_d64", 24, 1)["proof_levels"] + levels = extract_summary(log, "onehot_fp128", 24, 1)["proof_levels"] self.assertEqual(proof_level_component_bytes(levels[0]), 20) output = io.StringIO() @@ -367,7 +367,7 @@ def test_matrix_embeds_main_delta_in_every_numeric_metric(self) -> None: current = normalize_case_summary( { - "mode": "onehot_fp128_d64", + "mode": "onehot_fp128", "num_vars": 32, "num_polys": 1, "exit_code": 0, @@ -407,10 +407,67 @@ def test_matrix_embeds_main_delta_in_every_numeric_metric(self) -> None: self.assertIn("8.0 MiB", report) self.assertIn("4,096 bytes", report) self.assertIn("nv32Onehot256", report) - self.assertIn("D=64", report) + self.assertNotIn("D=64", report) self.assertNotIn("Proof B", report) self.assertNotIn("Setup Mode", report) + def test_adaptive_case_label_omits_ring_dimensions_and_mixed_dimension_config(self) -> None: + from scripts.profile_bench_report import human_case_label, normalize_case_summary + + summary = normalize_case_summary( + { + "mode": "onehot_fp128", + "num_vars": 32, + "num_polys": 1, + "exit_code": 0, + "planned_levels": [ + {"level": 0, "d_a": 256, "d_b": 64, "d_d": 64} + ], + } + ) + + self.assertEqual(human_case_label(summary), "Fp128 - nv32Onehot256") + + def test_adaptive_multi_group_case_label_omits_ring_dimensions(self) -> None: + from scripts.profile_bench_report import human_case_label, normalize_case_summary + + summary = normalize_case_summary( + { + "mode": "onehot_fp128_multi_group", + "num_vars": 32, + "num_polys": 4, + "exit_code": 0, + "planned_levels": [ + {"level": 0, "d_a": 256, "d_b": 64, "d_d": 64} + ], + } + ) + + self.assertEqual( + human_case_label(summary), + "Fp128 - nv32Onehot256 - Batched4 - MultiGroup", + ) + + def test_case_label_keeps_non_dimension_topology_variant(self) -> None: + from scripts.profile_bench_report import human_case_label, normalize_case_summary + + summary = normalize_case_summary( + { + "mode": "onehot_fp128_multi_chunk_w4r2", + "num_vars": 32, + "num_polys": 1, + "exit_code": 0, + "planned_levels": [ + {"level": 0, "d_a": 256, "d_b": 64, "d_d": 64} + ], + } + ) + + self.assertEqual( + human_case_label(summary), + "Fp128 - nv32Onehot256 - MultiChunkW4R2", + ) + def test_full_report_renders_overhauled_tables(self) -> None: from scripts.profile_bench_report import render_report @@ -456,7 +513,7 @@ def test_full_report_renders_overhauled_tables(self) -> None: "root_variant": "terminal", } case = { - "mode": "onehot_fp128_d64", + "mode": "onehot_fp128", "num_vars": 32, "num_polys": 1, "setup_contribution_mode": "direct", @@ -513,10 +570,10 @@ def test_configured_cases_treats_setup_mode_as_case_dimension(self) -> None: (), { "case": [ - "onehot_fp128_d64:32:1", - "onehot_fp128_d64:32:1:recursive", + "onehot_fp128:32:1", + "onehot_fp128:32:1:recursive", ], - "mode": "onehot_fp128_d64", + "mode": "onehot_fp128", "num_vars": 32, "num_polys": 1, }, @@ -536,7 +593,7 @@ def test_write_aggregate_summaries_propagates_sibling_failure(self) -> None: write_aggregate_summaries, ) - case = BenchmarkCaseSpec(mode="onehot_fp128_d64", num_vars=24, num_polys=1) + case = BenchmarkCaseSpec(mode="onehot_fp128", num_vars=24, num_polys=1) pr_dir = pathlib.Path("pr-root") base_dir = pathlib.Path("base-root") ok_summary = { diff --git a/specs/archive/2026-Q3/group-local-opening-points.md b/specs/archive/2026-Q3/group-local-opening-points.md index caa785b21..efab7d0d7 100644 --- a/specs/archive/2026-Q3/group-local-opening-points.md +++ b/specs/archive/2026-Q3/group-local-opening-points.md @@ -837,7 +837,7 @@ above and run the representative end-to-end profile: ```bash cargo run -p akita-pcs --release --no-default-features \ - --features parallel,profile-onehot-fp128-d64 \ + --features parallel,profile-onehot-fp128 \ --example profile ``` diff --git a/specs/distributed-planner.md b/specs/distributed-planner.md index ea85dc65c..9b47f5e67 100644 --- a/specs/distributed-planner.md +++ b/specs/distributed-planner.md @@ -676,33 +676,56 @@ For each new multi-chunk family: // keys: AkitaScheduleLookupKey::new(num_vars, num_polys) — identical to D64OneHot ``` -4. **`EmitSpec.policy`**: full `PlannerPolicy` including - `witness_chunk: ChunkedWitnessCfg::d64_production()` (via `policy_of`). +4. **`EmitSpec.policy`**: full `PlannerPolicy` including the selected + `MultiChunkProfileId` and inherited ring-dimension schedule (via `policy_of`). 5. Run the same DP regen hook: `find_schedule(key, &policy, …)`. -#### Step 10 — New `Cfg` types and `ALL_GENERATED_FAMILIES` rows (`akita-config`) - -Add **D = 64 multi-chunk companions** for the existing non-zk D64 families: - -| Base module | Multi-chunk module | Base `Cfg` (pattern) | -|-------------|-------------------|----------------------| -| `fp128_d64_onehot` | `fp128_d64_onehot_multi_chunk` | `fp128::D64OneHotMultiChunk` | -| `fp128_d64_dense` | `fp128_d64_dense_multi_chunk` | `fp128::D64DenseMultiChunk` | - -The companions delegate every layout parameter to their base `Cfg` via the -`impl_multi_chunk_companion!` helper and override only `chunked_witness_cfg()` -(→ `ChunkedWitnessCfg::d64_production()`) and `schedule_catalog()`. - -Each multi-chunk `Cfg`: - -- `D = 64`, same field / decomposition / one-hot settings as its base. -- `chunked_witness_cfg()` returns e.g. - `ChunkedWitnessCfg::d64_production()` (`MultiChunkProfileId::W8R2`: 8 chunks, 2 - production constants — document on the preset). -- `policy_of::()` picks up the config via the trait method (no override). -- `schedule_catalog()` points at the `_multi_chunk.rs` table. -- `runtime_schedule(key)` calls `resolve_schedule(key, &policy_of::(), …)`; - no key mutation — multi-chunk behavior comes entirely from policy + catalog. +#### Step 10 — Current `Cfg` types and generated-family rows (`akita-config`) + +Direct fp128 multi-chunk configs are companions of the canonical adaptive +families, so they copy `RingDimensionScheduleMode::AdaptiveDimension` as well as +the field, decomposition, and security policy: + +| Base module | Multi-chunk module | `Cfg` | +|-------------|-------------------|-------| +| `fp128_onehot` | `fp128_onehot_multi_chunk` | `fp128::OneHotMultiChunk` (W8R2) | +| `fp128_onehot` | `fp128_onehot_multi_chunk_w2r2` | `fp128::OneHotMultiChunkW2R2` | +| `fp128_onehot` | `fp128_onehot_multi_chunk_w4r2` | `fp128::OneHotMultiChunkW4R2` | +| `fp128_dense` | `fp128_dense_multi_chunk` | `fp128::DenseMultiChunk` (W8R2) | + +`impl_multi_chunk_companion!` overrides only the chunk profile and catalog +function. `policy_of::()` therefore combines the base adaptive search +domain (`A ∈ {64,128,256}`, `B,D ∈ {64,128}`, two searched levels, then +uniform D64) with the selected W/R chunk profile. Candidate geometry, witness +contraction, setup footprint, and proof bytes are all priced with +`chunks_at_level(level)`. + +The production recursive W8R2 family uses +`RecursiveCommitmentConfig`. The recursive suffix DP searches +the same bounded adaptive role-dimension domain while jointly pricing direct +and setup-offloaded successors. The legacy +`RecursiveCommitmentConfig` family remains available only +as an explicit fixed-D64 comparison catalog. + +The regenerated scalar rows demonstrate that chunking participates in the +search instead of being stamped on afterward: + +| Family/key | Root A/B/D | Level-1 A/B/D | Partition at root/L1 | +|------------|------------|----------------|----------------------| +| one-hot W2R2, nv=14 | 64/64/64 | 64/64/64 | 2 / 2 chunks | +| one-hot W2R2, nv=32 | 256/64/64 | 256/64/64 | 2 / 2 chunks | +| one-hot W4R2, nv=32 | 256/64/64 | 256/64/64 | 4 / 4 chunks | +| one-hot W8R2, nv=32 | 256/64/64 | 256/64/64 | 8 / 8 chunks | +| dense W8R2, nv=16 | 64/64/64 | 64/64/64 | 8 / 8 chunks | + +Level 2 and later use the configured uniform-D64 suffix and a single witness +chunk. Standalone precommit profiles are generated from the same adaptive +config, so their selected A dimension can vary with group shape (for example, +the W2R2 profile grid contains D64, D128, and D256 A commitments while B stays +D64). Adaptive search is currently scalar-root only: a request containing +precommitted groups preserves their frozen profiles and uses the existing +uniform-D64 grouped-root fallback. Recursive setup planning remains out of +scope. Wire modules in [`crates/akita-schedules/src/generated/mod.rs`](../crates/akita-schedules/src/generated/mod.rs) behind the new feature flags. @@ -726,14 +749,18 @@ behind the new feature flags. #### Step 12 — Regenerate tables ```bash -cargo run --release -p akita-config --bin gen_schedule_tables -- \ +cargo run --release -p akita-planner --features catalog-gen \ + --bin gen_schedule_tables -- \ crates/akita-schedules/src/generated ``` -Commit new files: +Commit the direct adaptive tables and their standalone-precommit companions: -- `crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk.rs` -- `crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk.rs` +- `crates/akita-schedules/src/generated/fp128_onehot_multi_chunk.rs` +- `crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_precommitted.rs` +- the corresponding W2R2 and W4R2 one-hot pairs +- `crates/akita-schedules/src/generated/fp128_dense_multi_chunk.rs` +- `crates/akita-schedules/src/generated/fp128_dense_multi_chunk_precommitted.rs` Non-zk only in this spec phase. diff --git a/specs/distributed-setup-offloading.md b/specs/distributed-setup-offloading.md index b2030aba2..1546ecce9 100644 --- a/specs/distributed-setup-offloading.md +++ b/specs/distributed-setup-offloading.md @@ -18,31 +18,34 @@ ## Summary -Akita already ships two independent verifier/prover-cost techniques for `D = 64` -one-hot presets: +Akita ships two independent verifier/prover-cost techniques for fp128 one-hot +presets: - **Recursive setup offloading** (`RecursiveCommitmentConfig`, `SetupContributionMode::Recursive`, Stage-3 setup-product sum-check, carried - setup-prefix opening). Generated table: `fp128_d64_onehot_recursive`. + setup-prefix opening). Production generated table: + `fp128_onehot_recursive`. - **Multi-chunk (distributed-prover) witness layout** (`ChunkedWitnessCfg`, `LevelParams::witness_chunk`, per-chunk folded responses `zⱼ`, shared `r̂` - tail). Generated tables: `fp128_d64_onehot_multi_chunk_w2r2`, - `fp128_d64_onehot_multi_chunk_w4r2`, etc. + tail). Direct generated tables now inherit the ordinary fp128 adaptive policy: + `fp128_onehot_multi_chunk`, `fp128_onehot_multi_chunk_w2r2`, and + `fp128_onehot_multi_chunk_w4r2`. -They have never been combined. The setup-offloading design record -(`specs/setup-offloading-planner.md`) explicitly lists *"Distributed or -multi-chunk setup offloading"* as a non-goal. +They are combined in the production W8R2 recursive catalog. The earlier +setup-offloading design record (`specs/setup-offloading-planner.md`) listed +*"Distributed or multi-chunk setup offloading"* as a non-goal for its original +slice; this follow-up closes that gap. This spec covers the **mix**: `8` witness chunks over `2` activated fold levels -(`W8R2`) **and** recursive setup offloading, for the `fp128 D=64` one-hot preset -only. `W8R2` is the single production slice shipped here; other chunk widths +(`W8R2`) **and** recursive setup offloading, for the adaptive fp128 one-hot +preset. `W8R2` is the single production recursive slice shipped here; other chunk widths (`W2R2`, `W4R2`, …) follow the same recipe but are out of scope. It is split into two parts: - **Part 1: the planner + generated schedule table.** A new generated family - `fp128_d64_onehot_recursive_multi_chunk_w8r2` is emitted by the config - `RecursiveCommitmentConfig`. The planner DP already - prices both techniques together; one latent gap was fixed (the chunked + `fp128_onehot_recursive_multi_chunk_w8r2` is emitted by the config + `RecursiveCommitmentConfig`. The planner DP searches + role dimensions and prices both techniques together; one latent gap was fixed (the chunked multi-group **root** fold did not skip candidates whose *main* group had fewer live blocks than `num_chunks`). See [Part 1: what landed](#part-1-what-landed). - **Part 2: the end-to-end prover / verifier / setup path.** The runtime @@ -56,22 +59,23 @@ two parts: ### Goal Make an evaluation opening prove and verify under -`AkitaCommitmentScheme>` +`AkitaCommitmentScheme>` for the shipped recursive profiling key (`final_group = (32, 2)`, `precommitteds = [(16, 1), (16, 1)]`), so that the leading two fold levels are **both** chunked (`num_chunks = 8`) **and** run the Stage-3 setup-product sum-check (`SetupContributionMode::Recursive`), with the carried setup-prefix opening discharged into the next fold's grouped opening batch — exactly as the generated table -`fp128_d64_onehot_recursive_multi_chunk_w8r2` prescribes. +`fp128_onehot_recursive_multi_chunk_w8r2` prescribes. ### Invariants -- **Config selects the family.** Only - `RecursiveCommitmentConfig` activates the mix: +- **Config selects the family.** The production config + `RecursiveCommitmentConfig` activates the mix: `recursive_setup_planning() == true` (from the adapter) and `chunked_witness_cfg() == W8R2` (delegated from the base - `D64OneHotMultiChunk`). `D == SETUP_OFFLOAD_D_SETUP == 64`. + `OneHotMultiChunk`). Its compile-time `D = 256` is the policy ceiling/default; + each generated fold carries exact A/B/D role dimensions. - **Chunk activation and offload depth are independent.** `num_activated_levels = R = 2` chunks fold levels `0, 1`. The setup-offloading planner independently compares direct and offloaded successors at every @@ -82,9 +86,16 @@ batch — exactly as the generated table `make_terminal_direct_step` reject `num_chunks > 1`). The former rule that both leading levels were unconditionally recursive is archival rollout context, not a current schedule invariant. -- **Uniform ring dimension.** Every role dimension is `D = 64`, so - `reject_mixed_d_multi_chunk` (the one hard multi-chunk/roles guard) always - passes. The mix is defined only for the uniform-D64 one-hot shape. +- **Adaptive role dimensions.** The first two levels search A in + `{64,128,256}` and B/D in `{64,128}`, componentwise nonincreasing from one + fold to the next; later levels use uniform D64. The shipped W8R2 key selects + `256/128/64` at root and L1, followed by `64/64/64`. The multi-chunk protocol + consumes the selected role geometry directly. +- **Prefix geometry follows its consumer.** A prefix produced by one edge is + committed using the exact A/B dimensions of the next fold that consumes it. + The shipped key therefore carries a `256/128` prefix into L1 and a `64/64` + prefix into L2. A catalog-wide default prefix dimension is identity metadata, + not the actual dimension of every adaptive prefix. - **Setup-prefix size is chunk-independent; its block split is not.** `active_setup_field_len` computes the setup-matrix footprint from role dimensions, so `natural_len` (hence `n_prefix`) is identical to the @@ -106,7 +117,7 @@ batch — exactly as the generated table ### Non-Goals -- Ring dimensions other than uniform `D = 64`. +- Recursive adaptive search beyond the configured two-level search window. - Chunk profiles other than `W8R2` (`num_chunks = 8`, `num_activated_levels = 2`). Other profiles (`W2R2`, `W4R2`, …) follow the same recipe but are out of scope for this rollout. @@ -141,7 +152,7 @@ the same planner, walker, prover, and verifier, and are mostly orthogonal: the plain recursive or plain multi-chunk tables. - **Multi-group + multi-chunk already round-trips** at runtime (`crates/akita-pcs/src/scheme/tests/onehot.rs::multi_group_multi_chunk_fold_round_trips`, - `fp128::D64OneHotMultiChunkW2R2`). + `fp128::OneHotMultiChunkW2R2`). - **Recursive setup offloading + multi-group already round-trips** (`crates/akita-pcs/tests/recursive_setup_e2e.rs`, `RecursiveCommitmentConfig`). @@ -164,9 +175,10 @@ the same planner, walker, prover, and verifier, and are mostly orthogonal: matching verifier check in `crates/akita-verifier/src/protocol/ring_switch.rs`. -The only hard incompatibility guard is `reject_mixed_d_multi_chunk` -(`crates/akita-verifier/src/protocol/ring_switch.rs`): multi-chunk requires -uniform role ring dimensions. The mix is uniform `D = 64`, so it passes. +The direct ring-relation path supports mixed A/B/D role dimensions together +with multi-chunk witness partitions. This recursive-setup-offloading family is +still deliberately uniform `D = 64`; adaptive direct multi-chunk catalogs are +a separate family and do not enable recursive setup planning. ## Part 1: what landed diff --git a/specs/mixed-ring-dimension-per-level.md b/specs/mixed-ring-dimension-per-level.md index bdefe72d9..8b6f640cc 100644 --- a/specs/mixed-ring-dimension-per-level.md +++ b/specs/mixed-ring-dimension-per-level.md @@ -2,12 +2,12 @@ | Field | Value | |---|---| -| Status | Direct scalar mixed-D planner search and catalog/runtime replay implemented; recursive setup, multi-chunk, and mixed multi-group integration deferred | +| Status | Adaptive direct, multi-chunk, grouped recursive-setup planning, catalog generation, and runtime replay implemented | | Review snapshot | 2026-07-28, planner reviewed on `main` at `af770e129` | | Benchmark snapshot | 2026-07-28, release build of `25a1e94a6` | | Recursive benchmark snapshot | 2026-07-28, working tree based on `af770e1296` | | Primary workload | fp128 one-hot, `nv = 36`, `np = 1` | -| Primary profile mode | `onehot_fp128_mixed_dim` | +| Primary profile mode | `onehot_fp128` | | Related spec | `specs/runtime-ring-cutover.md` | | Projected digit layout | `specs/role-native-projected-digit-layout.md` | | Planner implementation | `crates/akita-planner/src/schedule_params/` | @@ -48,14 +48,103 @@ dimension needed by this experiment: - **Within a level:** the A, B, and D commitment matrices can use distinct dimensions `d_a/d_b/d_d`, subject to A-to-role projection divisibility. -The protocol, setup-contribution, quotient, and direct verifier paths consume -this geometry. The offline planner has an opt-in direct scalar search over -explicit per-matrix dimension tuples, and the fp128 nv32 one-hot family emits -and replays a catalog using that search. Recursive setup offload, direct -multi-chunk search, and heterogeneous mixed-D multi-group roots remain -explicitly deferred; the current multi-group expander still uses the ordinary -uniform-D contract. The benchmark profiles in this document remain synthetic -schedules built in `akita-pcs` test support unless a section says otherwise. +The protocol, setup-contribution, quotient, and verifier paths consume this +geometry. For the default direct scalar fp128 one-hot and dense families, +including direct multi-chunk variants, the offline planner searches the +admitted A dimensions and block splits. It currently derives B and D by minimum +secure rank before complete schedule comparison. Full Cartesian B/D +optimization for these direct families is deferred. + +Grouped recursive-setup requests use a distinct adaptive path. Their suffix DP +searches explicit per-matrix dimension tuples and jointly chooses role +dimensions, block geometry, commitment payload mode, and whether each supported +edge evaluates setup directly or offloads it through a carried setup-prefix +opening. Direct grouped roots without recursive setup planning preserve their +committed profiles and use the uniform D64 suffix policy. The fp128 direct and +recursive families emit and replay generated catalogs; prover and verifier do +not invoke the planner at runtime. + +For recursive schedules, adaptive search is deliberately scoped to grouped +requests with precommitted inputs: those inputs provide setup contributions +that can actually be offloaded. A scalar request under +`RecursiveCommitmentConfig` is rejected by the scalar mixed-search +entry point. This is a request-shape restriction, not a lack of adaptive +recursive support. + +The production recursive catalogs currently cover the profiling key with a +32-variable, two-polynomial final group and two 16-variable singleton +precommitted groups. The selected schedules are: + +```text +single chunk: + root 256/64/64 + L1 256/64/64 (consumes setup prefix committed at 256/64) + L2+ 64/64/64 + +W8R2: + root 256/128/64 (8 witness chunks) + L1 256/128/64 (8 chunks; consumes prefix at 256/128) + L2 64/64/64 (single chunk; consumes prefix at 64/64) + L3+ 64/64/64 +``` + +The frozen precommit descriptors remain part of the root lookup key. Root +precommits are selected independently at the uniform suffix A/B dimensions +`64/64`; their dimensions do not follow the adaptive final-group root. At every +offloaded edge the setup-prefix commitment inherits the consuming fold's exact +A/B dimensions; it does not use a global fixed prefix dimension. + +### Adaptive recursion implementation + +Supporting recursion required closing six planner/runtime gaps; registering an +adaptive base config on the old recursive planner would still have produced a +uniform-D64 suffix. + +1. **Do not take the grouped adaptive fallback.** Direct grouped requests still + preserve the established uniform-suffix fallback because their committed + input descriptors are frozen. A grouped request with + `recursive_setup_planning = true` now enters the setup-aware suffix DP, where + the root and recursive folds can search exact role tuples. +2. **Enumerate exact tuples under a per-role ceiling.** For each searched level, + the DP enumerates the Cartesian product of the configured A/B/D domains, + rejects non-divisor projections, and enforces + `next.d_role <= current.d_role` independently for A, B, and D. The selected + tuple becomes the child state's ceiling. At `num_search_levels`, enumeration + stops and the configured uniform suffix dimension is used. +3. **Price each tuple with its own geometry.** Root group expansion receives a + fixed exact A/B/D tuple, including the shared opening D used by frozen + precommits. Recursive candidates derive their fold challenge, extension + opening reduction bytes, block splits, matrices, ranks, and setup footprint + at that tuple. During adaptive levels all feasible block splits are retained + for comparison; after the search window the ordinary local split selection + is sufficient. +4. **Make setup-prefix dimensions edge-local.** A prefix is produced for a + successor but committed as an input of that successor. Prefix derivation + therefore receives the consuming candidate's exact A and B dimensions. + Prefix slot metadata, natural/padded length, SIS rows, and challenge config + all agree with those dimensions. This removes the old assumption that every + recursive prefix uses `Cfg::D`. +5. **Preserve enough information in the suffix frontier.** Two successor + schedules with the same ordinary outer-commitment payload can have different + Stage-3 setup-product payloads when their D/prefix geometry differs. The + parent-visible frontier key now contains both byte counts. Pruning only on + outer payload would discard a candidate that can be better after an + offloaded parent edge. +6. **Ship distinct catalog identities and runtime routes.** The generated + families `fp128_onehot_recursive` and + `fp128_onehot_recursive_multi_chunk_w8r2` bind the adaptive domains, + recursive selection policy, exact lookup keys, and selected schedules. + `RecursiveCommitmentConfig` and + `RecursiveCommitmentConfig` route to those tables. The + profiler and E2Es use these configs, so runtime proving never depends on the + offline search implementation. + +The recursive objective remains +`MinFirstDirectSetupThenPayload`: it first minimizes the setup footprint at the +first direct edge after any offloaded prefix, then exact proof payload and the +remaining deterministic tie-breaks. Dimension is not optimized in isolation; +larger A/B/D candidates survive only when their effect on ranks, witness +contraction, proof bytes, and the setup envelope wins under that objective. The implemented direct-scalar policy is: @@ -65,12 +154,18 @@ The implemented direct-scalar policy is: 3. deterministic canonical tie-break only. ``` -This policy is catalog-bound for the fp128 nv32 mixed-D family. Its generated -identity uses `MinSetupMatrixFieldElementsThenProofPayload`; callers that pass -an explicit mixed dimension domain with a proof-payload policy are rejected +This policy is catalog-bound for the default direct scalar fp128 one-hot and +dense families. Their generated identities use +`MinSetupMatrixFieldElementsThenProofPayload`. A caller that supplies an +adaptive dimension policy with a proof-payload selection policy is rejected rather than silently changing objectives. Prover and verifier remain catalog-only and never run the planner. +The current implementation applies this objective after choosing B and D by +minimum secure rank. It is therefore not a global optimum over the full A/B/D +Cartesian product. The complete Cartesian search and matching oracle are P0 +follow-up work below. + The currently preferred measured design remains: ```text @@ -151,9 +246,14 @@ decomposition. Their physical columns use ### Across-level setup rule -The setup is generated at `CommitmentConfig::D`. Every scheduled matrix -dimension must be supported by field dispatch and divide the generation -dimension. `validate_schedule_ring_dims` is the schedule boundary check. +The public setup matrix is a dimension-free stream of base-field elements. +Setup capacity is the largest physical matrix requirement in the schedule. +There is no setup generation dimension and no global divisibility rule. + +Each scheduled A, B, and D dimension must have support for its protocol role +and its SIS security table. A dimensions must also have production fold +challenge support. The schedule separately enforces A-to-role projection and +per-level transition rules. ### One compact outgoing witness per multi-group level @@ -180,12 +280,13 @@ from the selected dimensions, plan the complete continuation from the exact outgoing witness, and retain enough alternatives to optimize the non-additive setup objective correctly. -The approved search policy limits dimension choice to L0 and L1. Dimensions -are component-wise non-increasing, and L2 and later are uniform D64. Rank-one -dimension pruning is not part of the authoritative search: B and D widths -depend on upstream ranks, so a geometry-only bucket is not an equivalence -class. The correctness baseline is exhaustive L0/L1 enumeration with Pareto -frontier retention and descriptor-byte tie-breaking. +The target search policy limits dimension choice to L0 and L1. Dimensions are +component-wise non-increasing, and L2 and later are uniform D64. The target +does not use rank-one dimension pruning because B and D widths depend on +upstream ranks. A geometry-only bucket is not an equivalence class. The target +correctness baseline is exhaustive L0/L1 tuple enumeration with Pareto frontier +retention and descriptor-byte tie-breaking. The current implementation reaches +this baseline for A choices and block splits, but not for B and D choices. The direct-schedule score is: @@ -241,7 +342,8 @@ verifier-reachable dynamic programming. | Policy input | Current meaning | |---|---| -| `ring_dimension` | One scalar `Cfg::D`, used as A, B, D, terminal, setup-generation, and suffix dimension | +| `uniform_ring_dimension` | Uniform-only A/B/D candidate; ignored by adaptive search | +| `ring_dimension_schedule_mode` | Uniform candidate or catalog-bound adaptive A/B/D domains plus the uniform suffix | | `decomposition`, `basis_range` | Digit policy; root basis is pinned to the configured minimum, later bases are searched and non-decreasing | | SIS profile, policy, table digest | Exact role-aware minimum-rank lookup identity | | ring challenge closure | Sparse A-role fold challenge selected by dimension | @@ -259,54 +361,46 @@ The shipped selection policies are: | Policy | Current comparison | |---|---| | `MinEstimatedProofPayload` | Direct schedules: exact proof payload only | +| `MinSetupMatrixFieldElementsThenProofPayload` | Adaptive direct schedules: physical setup fields, then exact proof payload, then descriptor bytes | | `MinFirstDirectSetupThenPayload` | Recursive setup schedules: first later direct setup scan, then exact proof payload, subject to an optional host budget | -The ordinary direct policy computes a setup envelope but does not use it for -selection. The fp128 `best_dense_schedule` and `best_onehot_schedule` helpers -compare separately generated uniform-D64 and uniform-D128 catalogs by proof -bytes, then use smaller uniform D as a tie-break. They are family selectors -outside the schedule DP; they cannot produce a mixed schedule. +The ordinary uniform direct policy computes a setup envelope but does not use +it for selection. The canonical fp128 one-hot and dense presets each resolve +one adaptive generated family; there is no runtime cross-family selector. ### Current search algorithm -For one fixed scalar D, the scalar planner does the following: - -1. At the root, enumerate the configured root `log_basis` and valid - `block_index_bits`. -2. Derive A/B/D widths, coefficient bounds, and minimum secure ranks. -3. Derive the exact outgoing witness field length. -4. Enter the memoized suffix search at that exact boundary. -5. At each recursive `(level, witness_len, current_basis, incoming_prefix)` - state: - - enumerate non-decreasing bases; - - select one block split per basis with `layout_candidate_score`; - - compare direct termination with another fold; - - optionally compare direct and setup-offloaded child edges. -6. Materialize the selected typed `FoldSchedule`. -7. Recompute proof bytes and setup envelope and reject any disagreement with - the cached estimates. - -`layout_candidate_score` combines next-witness physical width, challenge work, -chunk work, and chunk imbalance. It is a local recursive-split heuristic. -The source explicitly notes that selecting the smallest next witness is not the -same as globally minimizing current proof plus suffix cost. Therefore the -current planner should not be described as exhaustive over all recursive -block splits, even though the suffix termination decision is dynamic -programming. - -The suffix memo currently retains two maps per first-fold basis: - -- best by first-direct-setup then payload; -- best by payload. - -That is sufficient for the two current scalar-D policies. It is not sufficient -for a setup-envelope-first mixed-D objective. +The shared suffix planner now does the following: + +1. At the root, enumerate the configured `log_basis`, valid block splits, and + every exact A/B/D tuple admitted at level 0. +2. Derive tuple-local widths, coefficient bounds, secure ranks, extension + opening bytes, and the exact outgoing witness length. Frozen precommit D + segments are projected once to the selected shared D and added after the + main group's A-to-D projection. +3. Enter the memoized suffix search with the exact witness boundary and the + selected tuple as the componentwise dimension ceiling. +4. At each recursive state, enumerate non-decreasing bases and every exact + tuple below that ceiling. Adaptive searched levels retain every feasible + block split; uniform suffix levels use `layout_candidate_score` to select the + local split per basis. +5. Compare direct termination with another fold and, for recursive-setup + policies, compare direct and setup-offloaded child edges. +6. Materialize the selected typed `FoldSchedule`; recompute proof bytes and + setup envelope and reject any disagreement with the cached estimates. + +The suffix memo distinguishes the dimension ceiling and retains both +first-direct-setup and payload objectives. Its parent-visible frontier key +contains the successor's ordinary outer payload and Stage-3 payload, so an +adaptive D/prefix choice cannot be incorrectly pruned merely because its B +payload ties another successor. ### Historical pre-cutover mixed-D gap The following list records the implementation gaps that motivated this cut. -The direct scalar path and its generated catalog now address the scalar items; -the multi-group and recursive items remain deferred as stated above. +They are historical: the adaptive scalar, multi-chunk, and grouped recursive +paths now address them. Direct grouped requests still intentionally use the +uniform-suffix fallback rather than searching a heterogeneous root. The production planner assumes uniform D in all candidate derivation: @@ -332,29 +426,29 @@ rebuilt selected matrices, and recomputed boundaries outside the native planner. A native planner must produce the final matrices directly; it must not generate a uniform candidate and retarget it after selection. -### Future broader ring-dimension policy +### Target ring-dimension policy -Replace the overloaded scalar planner dimension with a plain-value search -policy conceptually equivalent to: +The planner uses a plain-value search policy conceptually equivalent to: ```rust PlannerRingDimensionPolicy { - setup_generation_dimension, a_candidates, b_candidates, d_candidates, + uniform_suffix_dimension, } ``` The exact Rust shape is an implementation detail, but the semantics are normative: -- `setup_generation_dimension` is the setup envelope's generation ring - dimension. It must be a supported power of two and a multiple of every - admitted A/B/D dimension. +- The public setup matrix has no ring dimension. Candidate admission does not + use a setup carrier or require divisibility against one. - `a_candidates` are dimensions with production fold-challenge support and an audited A-role SIS cell. - `b_candidates` and `d_candidates` are independently audited role domains. +- `uniform_suffix_dimension` is the dimension used after the adaptive search + prefix. It must be admitted for A, B, and D. - Candidate lists are sorted, unique, non-empty, and catalog-identity-bound. - The planner enumerates the Cartesian product and keeps only tuples satisfying the canonical A-to-role divisibility validation. @@ -363,6 +457,11 @@ normative: - Terminal candidates use the A domain because a terminal has only the inner commitment matrix. +The current bounded fp128 implementation is a partial implementation of this +target. It enumerates A but derives B and D locally by minimum secure rank. The +P0 follow-up must enumerate the full role-valid Cartesian product and apply the +catalog objective only after each complete schedule has been priced. + For fp128 one-hot, the intended eventual role domains are: ```text @@ -424,8 +523,9 @@ are removed. For every explicit tuple `(d_a, d_b, d_d)`, basis, and block split, derive the candidate in this order: -1. Validate the tuple, input-witness alignment, setup-generation divisibility, - challenge support at `d_a`, and level/chunk constraints. +1. Validate role projection within the tuple, input-witness alignment, + role-specific dispatch/SIS coverage, challenge support at `d_a`, and + level/chunk constraints. 2. Derive root or recursive block geometry using `d_a`. 3. Derive A's native decomposed width, A collision bucket, and minimum secure rank at `d_a`. @@ -658,10 +758,7 @@ canonical maximum group carrier. Group order must not influence the result. Outgoing sizing must call the compact `WitnessLayout` and successor-domain geometry rather than recomputing ring slots. Authenticated order fixes bytes; changing stable group identifiers without changing that order must not change -the length. The planner must replace current uses of -`policy.uniform_ring_dimension` in `d_segment_width` and carrier sizing with -the selected shared D and the canonical maximum group carrier. Group order -must not influence the result. +the length. ### Generated catalog and replay integration @@ -724,11 +821,11 @@ was required; it is not an active implementation contract. The planner must be independent of hash-map iteration and thread scheduling: -- require `PlannerPolicy::ring_dimension_candidates` to be strictly sorted, - duplicate-free, and non-empty so the catalog-bound slice has one value - identity; -- reject tuples that fail native role-projection validation or whose role dimensions are - not divisors of the setup-generation dimension; +- require each catalog-bound A/B/D candidate domain to be strictly sorted, + duplicate-free, and non-empty; +- reject role dimensions without protocol-dispatch, challenge, or SIS-table + coverage; candidate pairing separately enforces A-source-to-role projection + divisibility; - enumerate bases, dimensions, and splits in a documented order; - store frontiers in ordered collections or sort before selection/emission; - compare semantic cost components first; @@ -758,7 +855,8 @@ byte-identical. 1. Make physical setup field elements the canonical planner/setup accounting unit. 2. Add the new cost/selection identity without changing existing policy IDs. -3. Separate setup-generation dimension from candidate dimensions. +3. Remove setup-generation dimension from candidate admission and setup + accounting. 4. Bind candidate domains and challenge coverage into catalog identity. ✅ 5. Merge D512 A coverage into one canonical SIS table digest before admitting D512. @@ -778,16 +876,16 @@ byte-identical. 7. Select by setup field elements, then proof bytes, then descriptor bytes. 8. Keep recursive setup families on singleton D64. -#### Cut 2: catalog replay and shipped adaptive family (implemented for fp128 one-hot) +#### Cut 2: catalog replay and shipped adaptive families (implemented for fp128 one-hot and dense) 1. Make the canonical generated-entry walker replay per-matrix/per-level dimensions. 2. Add DP-to-generated-to-runtime exact parity tests. -3. Add one adaptive fp128 one-hot family rather than another set of fixed-D - selector wrappers. +3. Add adaptive fp128 one-hot and dense families rather than another set of + fixed-D selector wrappers. 4. Regenerate tables and update setup capacity/cache identity. -#### Cut 3: broader topology +#### Historical Cut 3 plan: broader topology 1. Enable direct multi-chunk search. 2. Enable multi-group final-root dimension search with frozen precommits. @@ -796,27 +894,27 @@ byte-identical. 4. Remove synthetic profile adapters only after planner-selected schedules reproduce their coverage and benchmarks. -### Implementation checkpoint and planner example +### Historical direct-scalar checkpoint and planner example -The current branch implements the first offline direct scalar cut while -preserving all generated catalogs: +This checkpoint described the first offline direct scalar cut. It is retained +as rollout history and is superseded by the adaptive recursion implementation +above: -- `PlannerPolicy::ring_dimension_candidates` is the one catalog-bound source - of admitted `(d_a, d_b, d_d)` tuples, validated against the policy's setup - generation dimension; -- the one canonical `find_schedule` entry point dispatches from that policy - slice: an exact setup-generation singleton preserves the uniform objective, - while any other admitted domain selects by physical setup field elements and - then exact modeled proof bytes; +- `RingDimensionScheduleMode::AdaptiveDimension` is the catalog-bound source + of independently audited A/B/D domains and the D64 suffix; +- the one canonical `find_schedule` entry point dispatches by schedule mode: + uniform mode preserves the proof-payload objective, while adaptive mode + selects by physical setup field elements and then exact modeled proof bytes; - root and recursive candidates derive role-local widths, SIS keys, and - matrices directly; -- L0 and L1 exhaustively enumerate splits over admissible, component-wise - descending tuples; + matrices directly after choosing A and deriving B and D by minimum secure + rank; +- L0 and L1 exhaustively enumerate block splits and admissible, + component-wise descending A choices; - dimensions are uniform D64 from L2 through the terminal; -- rank-one dimension pruning is disabled in the authoritative mixed search; - a test-only unpruned traversal checks the production frontier and canonical - selection while deliberately sharing canonical candidate construction and - pricing primitives; +- a test-only unpruned traversal checks the production frontier and canonical + selection over an A-varying domain with B and D fixed at D64. It deliberately + shares canonical candidate construction and pricing primitives. It does not + establish global optimality over the full B/D domain; - hand-calculated regressions independently pin exact field-element setup rounding, candidate-local EOR pricing, unsupported SIS-cell skipping, and complete-schedule descriptor ties; @@ -824,11 +922,12 @@ preserving all generated catalogs: L2+ states canonicalize to D64 and reuse the fixed planner's split policy; - mixed-boundary states retain the required setup/proof alternatives per exact parent-visible first fold; -- recursive setup policies are rejected by the mixed entry point and continue - to use the existing grouped planner. +- scalar recursive requests without precommitted inputs are rejected; grouped + recursive requests use the adaptive setup-aware suffix planner. `crates/akita-planner/examples/mixed_dimension_search.rs` exercises both the -implemented and preserved paths. With setup generation D256, `nv=18`, and: +implemented and preserved paths. With `nv=18` and the following candidate +tuples: ```text 64/64/64 @@ -857,22 +956,21 @@ Release-process measurements after the bounded-search change were: | 24 | 0.22 s | `256/128/128` | `128/64/64` | D64 | 524,288 | 90,976 | | 36 | 0.46 s | `256/128/128` | `64/64/64` | D64 | 67,108,864 | 99,368 | -The `nv=24` and `nv=36` rows supersede the earlier rank-one-pruned -checkpoint. Exhaustive L0/L1 enumeration admits the D256 root and selects it -because setup fields are the primary objective, even though the `nv=36` proof -is larger than the former pruned result. +The `nv=24` and `nv=36` rows supersede the earlier A-pruned checkpoint. +Exhaustive L0/L1 A enumeration admits the D256 root and selects it because +setup fields are the primary objective, even though the `nv=36` proof is +larger than the former pruned result. These are planner smoke-test wall times, not a controlled benchmark; the process and filesystem caches were warm after the first run. The material result is that `nv=24` and `nv=36` now complete normally. Before the bounded policy, `nv=24` exceeded one minute and `nv=36` was stopped after five minutes. -The speedup comes from policy, not approximate pruning: mixed dimensions and -exhaustive split enumeration stop after L1, monotonicity removes upward -transitions, and the complete D64 suffix reuses the existing fixed planner -split derivation. Rank-one dimension caps are intentionally absent from the -authoritative search until an equivalence key is proved and checked against the -unpruned traversal. +The speedup comes from stopping mixed dimensions and exhaustive block-split +enumeration after L1. Monotonicity removes upward transitions, and the complete +D64 suffix reuses the existing fixed planner split derivation. The current +local B/D rank choice also reduces the search space, but it is not equivalent +to the target Cartesian objective. The P0 follow-up must remove it. For the PR recursive multi-group shape, the new entry point returns the expected unsupported-policy error because mixed recursive setup is a later @@ -883,15 +981,18 @@ preservation, not planner-native recursive mixed-D support. ### Acceptance criteria -The list below is the complete heterogeneous-planner target. PR341's scoped -implementation satisfies items 1–10 and the scalar fp128 portion of items -11–12. Mixed multi-group replay, direct multi-chunk mixed search, and fp32/fp64 -mixed catalogs remain deferred work; they are not represented as shipped -capabilities by this PR. +The list below is the complete heterogeneous-planner target. This PR implements +the catalog and runtime path and the bounded scalar fp128 protocol path. It does +not yet satisfy the full planner optimality requirements in items 2 and 4. The +checked unpruned traversal varies A while holding B and D at D64, and production +chooses B and D by minimum secure rank before the complete schedule comparison. +Full Cartesian B/D search is P0 follow-up work. Mixed multi-group replay, +direct multi-chunk mixed search, and fp32/fp64 mixed catalogs also remain +deferred. This PR does not describe these items as shipped capabilities. 1. Existing `find_schedule` reproduces uniform schedules, estimates, and - generated/runtime descriptor bytes; the opt-in mixed entry point requires - uniform D64 in its domain. + generated/runtime descriptor bytes. An adaptive policy must admit D64 for + every role and uses uniform D64 from L2 onward. 2. A small-domain unpruned traversal agrees with the constrained L0/L1 search and selected score; independently calculated tests cover the concrete formulas that traversal shares with production. @@ -907,7 +1008,7 @@ capabilities by this PR. bytes, proof-byte estimates, level counts, witness transitions, and setup cost. 8. Catalog validation rejects changes to candidate domains, selection policy, - setup generation D, SIS digest, or challenge hooks. + SIS digest, or challenge hooks. 9. Runtime row misses reject without planner fallback or panic. 10. Existing uniform direct, recursive, multi-chunk, and multi-group benchmark paths retain their fast verifier kernels. @@ -922,7 +1023,7 @@ capabilities by this PR. | Test | Required assertion | |---|---| -| Candidate-domain validation | Sorted unique powers of two; setup D divisible by every role candidate; uniform D64 present; no component below D64 | +| Candidate-domain validation | Sorted unique role domains; uniform D64 suffix present; each advertised dimension has role-specific dispatch, challenge (A), and SIS-table coverage | | Role-width unit tests | B/D widths equal native width times exact A-source/role ratio | | SIS admission tests | Unsupported role/dimension/bucket/width is candidate infeasibility; malformed policy is an error | | Unpruned reference traversal | Constrained L0/L1 frontier and selected schedule match the same canonical candidate set without production pruning | @@ -941,7 +1042,7 @@ These tests describe the implemented direct scalar cut. A future mixed multi-group or mixed multi-chunk cut must add corresponding frozen-precommit, chunk-partition, and generated-replay rows before claiming those capabilities. -### Resolved search policy +### Target search policy The approved first planner cut uses the deterministic `(physical setup fields, proof bytes, descriptor bytes)` comparator subject to @@ -950,9 +1051,10 @@ two catalog-bound constraints: 1. only L0 and L1 search mixed dimensions; 2. dimensions never increase and L2+ is uniform D64. -Rank-one pruning is intentionally absent from this cut. Reintroduce it only -after proving an equivalence key and checking it against the unpruned -traversal. +A rank-one pruning is absent from this cut. B and D still use a local minimum +rank choice, which is not equivalent to the complete schedule objective. The +P0 Cartesian follow-up must remove that choice. Any later pruning requires an +equivalence proof checked against a full-domain traversal. Measured verifier latency remains a possible later objective. It requires a versioned deterministic work model; host timings are not planner inputs. @@ -1245,11 +1347,11 @@ continue to cover mixed-D search and validation at the planning boundary. ### Lower-level coverage -- planner tests compare the mixed Pareto frontier with an unpruned traversal, - show that a lower D256 A rank can reduce B width even after both B matrices - reach rank one, preserve a lower-proof child when a larger parent setup masks - child setup differences, and require descriptor-identical concurrent - generation. +- planner tests compare the mixed Pareto frontier with an A-varying unpruned + traversal whose B and D dimensions remain D64. They also show that a lower + D256 A rank can reduce B width after both B matrices reach rank one, preserve + a lower-proof child when a larger parent setup masks child setup differences, + and require descriptor-identical concurrent generation. - `akita-types` setup-contribution span tests compare dense, materialized, direct, deferred, single-chunk, multi-chunk, and mixed-role projections. - verifier ring-switch tests check prepared relation geometry and deferred @@ -1257,8 +1359,8 @@ continue to cover mixed-D search and validation at the planning boundary. - multi-group parameter tests check group-local dimensions, row offsets, compact-length independence from stable group identifiers, and descending group A dimensions. -- recursive and distributed setup-offload E2Es cover the deferred verifier - path under their production feature guards. +- recursive and distributed setup-offload E2Es cover adaptive generated-table + replay under their production feature guards. - setup-prefix selection tests reject insufficient natural and padded capacity, while the recursive mixed-D E2E checks the exact dynamic D128 slot identity against canonical Stage 3 sizing and prepared setup capacity. @@ -1459,9 +1561,9 @@ form: - commit is about 28–29% slower in both workloads; - the plain prover is 58.5% slower, while W8R2 amortizes most of that penalty and is 5.5% slower; -- the larger generation dimension sharply reduces the expanded setup vector; - for W8R2 it also reduces NTT cache and peak RSS, but the plain case needs - D256, D128, and D64 prepared slots and therefore uses more cache and RSS; +- the mixed schedule sharply reduces the expanded setup vector; for W8R2 it + also reduces NTT cache and peak RSS, but the plain case needs D256, D128, and + D64 prepared slots and therefore uses more cache and RSS; - W8R2 proof size improves by 7,404 bytes, while the plain proof grows by 2,213 bytes. @@ -1528,15 +1630,15 @@ cargo build --release -p akita-pcs --example profile \ python3 scripts/profile_bench_report.py run \ --binary ./target/release/examples/profile \ - --output-dir /tmp/akita-recursive-d64 \ + --output-dir /tmp/akita-recursive-adaptive \ --runs 2 --warmups 1 \ - --case onehot_fp128_d64_multi_group_recursive:32:4:recursive + --case onehot_fp128_multi_group_recursive:32:4:recursive python3 scripts/profile_bench_report.py run \ --binary ./target/release/examples/profile \ - --output-dir /tmp/akita-recursive-w8r2-d64 \ + --output-dir /tmp/akita-recursive-w8r2-adaptive \ --runs 2 --warmups 1 \ - --case onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2:32:4:recursive + --case onehot_fp128_multi_group_recursive_multi_chunk_w8r2:32:4:recursive ``` The archived recursive mixed-D runs are no longer reproducible through @@ -1612,10 +1714,19 @@ back. ### P0: broaden cataloged mixed planning -The direct scalar fp128 one-hot family completes the bounded Cut 2 path. The -next planner work is multi-group and recursive-setup admission under separately -specified objectives. Remove the D512 D256-promotion heuristic only after the -native planner reproduces or improves its geometry. +The direct scalar fp128 one-hot and dense families complete the catalog and +runtime part of the bounded Cut 2 path. Their planner does not yet produce the +global optimum over the full A/B/D Cartesian product. For example, at fp128 +one-hot `nv=14`, the current search selects `256/64/64` with 73,764 proof bytes. +An explicit tuple traversal selects `256/128/128` with the same 65,536 setup +field elements and 73,652 proof bytes. + +The first follow-up must enumerate every role-valid B/D choice at L0 and L1, +remove the local rank-based dimension choice, and compare the selected score +and descriptor against a full-domain traversal. Later planner work includes +multi-group and recursive setup admission under separately specified +objectives. Remove the D512 D256-promotion heuristic only after the native +planner reproduces or improves its geometry. ### P1: production heterogeneous-group admission @@ -1629,8 +1740,8 @@ row. Setup-prefix offload still uses the D64 registry contract for catalog recursive families. A production mixed batch whose common relation dimension is -below 64 remains rejected until setup generation, registry lookup, planner -admission, and verifier dispatch select `d_setup` consistently. +below 64 remains rejected until setup-prefix materialization, registry lookup, +planner admission, and verifier dispatch select `d_setup` consistently. ### P2: expand the sweep diff --git a/specs/modular-planner-and-precommit-roles.md b/specs/modular-planner-and-precommit-roles.md index fa6c064c5..0e01260b4 100644 --- a/specs/modular-planner-and-precommit-roles.md +++ b/specs/modular-planner-and-precommit-roles.md @@ -52,16 +52,14 @@ search, and one canonical complete schedule selector for every current search path. The shipped root `log_basis` is 3 for all field widths. Recursive levels remain -planner-selected. The remaining root precommit implementation still runs a -hypothetical complete schedule under singleton basis range `(3, 3)` and -extracts the root commitment parameters. That probe is a temporary bridge. A -hypothetical suffix can influence root geometry even though the suffix will -never be used. +planner-selected. Root precommit generation directly selects a local recipe +under singleton basis range `(3, 3)`. Adaptive final-group policies use their +uniform suffix dimension for both precommit A and B, so a hypothetical suffix +cannot influence the frozen precommit geometry. -The stacked planner unification PR will remove that bridge and make the modules -in this specification the only search path. It must preserve the strict -selection policies documented below before introducing any proof byte slack or -fold count preference. +The stacked planner unification PR will make the modules in this specification +the only search path. It must preserve the strict selection policies documented +below before introducing any proof byte slack or fold count preference. ## Terminology @@ -541,9 +539,9 @@ materialization or runtime validation. #### Root precommit -- [ ] The full-schedule precommit probe is removed. -- [ ] Root-precommit recipes are selected directly at root basis 3. -- [ ] The selector uses exact materialized \(WZ+E+T\) widths. +- [x] The full-schedule precommit probe is removed. +- [x] Root-precommit recipes are selected directly at root basis 3. +- [x] The selector uses exact materialized \(WZ+E+T\) widths. - [ ] One recipe is deterministic across its declared compatibility domain. - [ ] Conservative basis-envelope rank widening is absent. - [ ] Commitments bind the complete selected descriptor. diff --git a/specs/profile-bench-coverage-matrix.md b/specs/profile-bench-coverage-matrix.md index aab388112..2fe18545f 100644 --- a/specs/profile-bench-coverage-matrix.md +++ b/specs/profile-bench-coverage-matrix.md @@ -57,12 +57,12 @@ The checked-in workflow currently runs: | `dense_fp128_d64` | fp128 | dense | 24 | 1 | D64 | `direct` | fp128 dense smoke at the proof-size-optimal ring dimension (D64 beats D128 by ~18-22%). | | `onehot_fp128_d64` | fp128 | 1-of-256 one-hot | 32 | 1 | D64 | `direct` | Explicit fp128 one-hot mode at the proof-size-optimal ring dimension. fp128 folds aggressively enough to stay at nv=32 under the eq-table budget. | | `onehot_fp128_d64` | fp128 | 1-of-256 one-hot batched | 30 | 4 | D64 | `direct` | Preserves same-point batched one-hot coverage. | -| `onehot_fp128_d64_multi_group_recursive` | fp128 | 1-of-256 one-hot batched multi-group | 32 | 4 | D64 recursive multi-group | `direct` | Direct setup-contribution baseline for the recursive setup comparison skill's canonical multi-group profile. | -| `onehot_fp128_d64_multi_group_recursive` | fp128 | 1-of-256 one-hot batched multi-group | 32 | 4 | D64 recursive multi-group | `recursive` | Same multi-group profile with `SetupContributionMode::Recursive`, so CI tracks recursive setup-product verifier work against the direct baseline. | -| `onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2` | fp128 | 1-of-256 one-hot batched multi-group W8R2 | 32 | 4 | D64 recursive multi-group W8R2 | `recursive` | Existing distributed recursive setup-offload row: `8` chunks, `2` leading levels. | -| `onehot_fp128_d64_multi_chunk_w2r2` | fp128 | 1-of-256 one-hot distributed chunked relation | 32 | 1 | D64 multi-chunk W2R2 | `direct` | `2` chunks, `2` leading levels. | -| `onehot_fp128_d64_multi_chunk_w4r2` | fp128 | 1-of-256 one-hot distributed chunked relation | 32 | 1 | D64 multi-chunk W4R2 | `direct` | `4` chunks, `2` leading levels. | -| `onehot_fp128_d64_multi_chunk_w8r2` | fp128 | 1-of-256 one-hot distributed chunked relation | 32 | 1 | D64 multi-chunk W8R2 | `direct` | Production distributed preset (`8` chunks, `2` leading levels). | +| `onehot_fp128_multi_group` | fp128 | 1-of-256 one-hot batched multi-group | 32 | 4 | adaptive | `direct` | Direct multi-group coverage using the canonical adaptive fp128 one-hot catalog. | +| `onehot_fp128_multi_group_recursive` | fp128 | 1-of-256 one-hot batched multi-group | 32 | 4 | adaptive recursive multi-group | `recursive` | Recursive setup-product coverage using the adaptive recursive companion catalog. | +| `onehot_fp128_multi_group_recursive_multi_chunk_w8r2` | fp128 | 1-of-256 one-hot batched multi-group W8R2 | 32 | 4 | adaptive recursive multi-group W8R2 | `recursive` | Distributed recursive setup-offload row: `8` chunks, `2` leading levels, with adaptive role dimensions. | +| `onehot_fp128_multi_chunk_w2r2` | fp128 | 1-of-256 one-hot distributed chunked relation | 32 | 1 | adaptive multi-chunk W2R2 | `direct` | `2` chunks, `2` leading levels. | +| `onehot_fp128_multi_chunk_w4r2` | fp128 | 1-of-256 one-hot distributed chunked relation | 32 | 1 | adaptive multi-chunk W4R2 | `direct` | `4` chunks, `2` leading levels. | +| `onehot_fp128_multi_chunk_w8r2` | fp128 | 1-of-256 one-hot distributed chunked relation | 32 | 1 | adaptive multi-chunk W8R2 | `direct` | Production direct distributed preset (`8` chunks, `2` leading levels). | Every active cell folds securely under honest committed-fold A-role pricing. The ring degree differs by field, for two distinct reasons: @@ -71,17 +71,11 @@ The ring degree differs by field, for two distinct reasons: securable under the reprice — they degrade to a cleartext root-direct proof and stop exercising a real folding commitment — so the smallest secure ring degree is D128. Those cells (and all fp16 cells) use D128 one-hot. -- **fp128:** D64 is the actual proof-size optimum for both dense and one-hot. - Measured against the runtime schedule's `total_bytes`, D64 produces ~18-23% - smaller proofs than D128 across the matrix shapes (e.g. one-hot nv=32: - 133,000 B at D64 vs 163,968 B at D128; dense nv=24: 131,656 B vs 160,080 B), - while still folding through 8-9 secure recursive levels. This is confirmed by - `current_d64_onehot_schedule_stays_within_audited_sis_widths` (securability) - and by the `best_dense_schedule` / `best_onehot_schedule` selectors, which - pick D64 (or D32), never D128. The earlier D128 fp128 cells were *not* - proof-size optimal; D32/D64 are the planner optima (D32 is marginally - smaller for fp128). The benchmark matrix tracks D64; use - `best_onehot_schedule` / `best_dense_schedule` to compare D32/D64/D128. +- **fp128:** the canonical direct dense and one-hot presets use their adaptive + generated catalogs. Each scheduled A/B/D dimension is selected offline from + the audited domain, and runtime code resolves that single canonical row. + Explicit D64 modes remain useful uniform baselines; there is no runtime + family selector comparing them with the adaptive presets. D32/D128 profile modes still exist for direct local comparisons, but neither the adaptive `full`/`onehot` selectors nor those comparison modes are part of @@ -192,7 +186,7 @@ The test-coverage cleanup touches: cases. - [x] The known long hosted-runner offender `onehot_fp16_d32:32:1` is documented as deferred rather than active. -- [x] `dense_fp128_d128` remains active at `nv=24`, not the earlier `nv=26` +- [x] `dense_fp128_d64` remains active at `nv=24`, not the earlier `nv=26` hosted-runner offender size. - [ ] `dense_fp64_d32:25:1` is re-enabled after a separate validation pass and completes setup, commit, prove, verify, proof summary, and proof @@ -282,7 +276,7 @@ This PR reduces per-case samples from 5 to 3 and expands the active matrix from 3 cases to 7 cases. The first 8-case candidate run was useful for finding costly coverage, but `onehot_fp16_d32:32:1` and `dense_fp128_d32:26:1` are too expensive for this PR's always-on hosted-runner budget. The active workflow -therefore keeps dense fp128 coverage at `nv=24` (now `dense_fp128_d128:24:1`) +therefore keeps dense fp128 coverage at `nv=24` (now `dense_fp128_d64:24:1`) and remains a smoke matrix, not an exhaustive benchmark suite. One PR run completed all 8 candidate benchmark cases with status `ok`, but the job @@ -432,8 +426,6 @@ cost only. - Re-enable `onehot_fp16_d32:32:1` after small-field one-hot prover cost is reduced or the CI runner budget changes. -- Revisit `dense_fp128_d128` at `nv=26` after dense fp128 commit/prove cost is - reduced or the CI runner budget changes. - Re-enable `dense_fp64_d32:25:1` after a separate dense fp64 validation pass. - Record the first fully successful expanded workflow runtime after the deferred cells are re-enabled. diff --git a/specs/recursive-mixed-ring-dimension-performance.md b/specs/recursive-mixed-ring-dimension-performance.md index 8ad242b1a..de4e0688a 100644 --- a/specs/recursive-mixed-ring-dimension-performance.md +++ b/specs/recursive-mixed-ring-dimension-performance.md @@ -275,28 +275,26 @@ local cost. The planner must retain alternatives that differ in: Prematurely dropping a locally larger candidate can lose the globally best schedule after a later transition. -## Planner implementation status on `feat/planner-per-matrix-d` +## Planner implementation status -The first planner-native cut is an opt-in offline scalar search. The canonical -`find_schedule` entry point reads the catalog-bound dimension domain directly -from `PlannerPolicy`. +The declarative planner supersedes the original tuple-domain implementation. +The canonical `find_schedule` entry point reads +`PlannerPolicy::ring_dimension_schedule_mode` directly. Implemented: -- `PlannerPolicy::ring_dimension_candidates` carries strictly sorted, unique - `(d_a, d_b, d_d)` tuples. Policy validation checks native role-projection - geometry and requires - every role dimension to divide `PlannerPolicy::ring_dimension`, the setup - generation dimension. -- `find_schedule` searches that policy-bound domain. An exact uniform - setup-generation singleton retains the historical proof-payload objective. +- `AdaptiveDimension` carries strictly sorted, unique A/B/D capability lists. + Policy validation requires every role dimension to divide + `PlannerPolicy::ring_dimension`, the setup generation dimension, and to + support the configured uniform suffix. +- `find_schedule` branches only over A. `UniformDimension` retains the + historical proof-payload objective. - Root and recursive candidates derive A/B/D SIS keys at their selected role dimensions. B and D physical widths include `d_a / d_role` projection subcolumns; candidates are built directly rather than retargeted afterward. -- The mixed search enumerates every admitted tuple and valid block split only - at L0 and L1. Tuples are component-wise non-increasing, L2 through the - terminal are uniform D64. Rank-one dimension pruning remains disabled until - an equivalence key is proved against the unpruned traversal. +- The adaptive search enumerates every admitted A and valid block split only at + L0 and L1. A is non-increasing, B/D are derived by minimum secure rank, and + L2 through the terminal are uniform D64. - Mixed-boundary suffix states retain the required `(setup, proof)` alternatives per exact first `CommittedGroupParams`, because the parent proof formula sees that first step. Once dimensions freeze at L2, candidate diff --git a/specs/schedule-catalog-ownership.md b/specs/schedule-catalog-ownership.md index 9271168c5..9fbd38290 100644 --- a/specs/schedule-catalog-ownership.md +++ b/specs/schedule-catalog-ownership.md @@ -712,8 +712,7 @@ zk = ["akita-planner/zk", "akita-types/zk", "akita-schedules?/zk"] schedules-default = [ "schedules-fp128-d64-onehot", "schedules-fp128-d64-dense", - "schedules-fp128-d128-onehot", - "schedules-fp128-d128-dense", + "schedules-fp128-onehot", "schedules-fp32-d128-onehot", "schedules-fp32-d256-onehot", "schedules-fp64-d128-onehot", @@ -893,8 +892,8 @@ Add `scripts/check_profile_ci_linkage.sh` after the head profile build: 1. Build with `--no-default-features --features parallel,profile-ci`. 2. Run `nm` (or `llvm-nm` if available) on `target/release/examples/profile`. -3. Fail if a known non-profile family symbol is present, for example a D128 full or - D256 one-hot table that is not in `profile-ci`. +3. Fail if a known non-profile family symbol is present, for example a full D128 + table that is not in `profile-ci`. This check is intentionally conservative. It only needs to catch accidental all-table linkage from default features or a stray dependency edge. diff --git a/specs/y-ring-trace-internalization.md b/specs/y-ring-trace-internalization.md index 24237787f..9b374f0e7 100644 --- a/specs/y-ring-trace-internalization.md +++ b/specs/y-ring-trace-internalization.md @@ -312,7 +312,7 @@ target. - [ ] Non-ZK and ZK e2e suites are green: `cargo nextest run --profile ci-non-zk` and `--profile ci-all-features`. - [ ] `cargo test -p akita-pcs --features logging-transcript --test transcript_hardening` green (event-stream equality after the `y_ring` absorb removal and `trace_coeff = γ²` derivation from post-witness `CHALLENGE_SUMCHECK_BATCH`). - [ ] A negative test: tampering the committed `e_hat` digits so that `sum_j b_j · e_folded_j` projects to the wrong subfield value is rejected (replaces the role of the current `y_ring` trace-mismatch rejection paths, e.g. `crates/akita-pcs/src/scheme/tests/batched.rs:419-421`). -- [ ] Profile shows the expected per-level shrink: `AKITA_MODE=onehot_fp128_d128 AKITA_NUM_VARS=32 cargo run --release --example profile` reports `y_ring_bytes = 0` at every level and total proof size reduced by the predicted amount. +- [ ] Profile shows the expected per-level shrink: `AKITA_MODE=onehot_fp128 AKITA_NUM_VARS=32 cargo run --release --example profile` reports `y_ring_bytes = 0` at every level and total proof size reduced by the predicted amount. ### Testing Strategy