From 97bfb0a225c1e98c7a32299d13c7012c67fb5991 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Wed, 5 Aug 2026 11:41:57 -0700 Subject: [PATCH 01/24] Update specs/mixed-ring-dimension-per-level.md numbers and removed unneeded params --- crates/akita-pcs/examples/profile/modes.rs | 58 -------- specs/mixed-ring-dimension-per-level.md | 157 +++++++++++---------- 2 files changed, 82 insertions(+), 133 deletions(-) diff --git a/crates/akita-pcs/examples/profile/modes.rs b/crates/akita-pcs/examples/profile/modes.rs index a7cb81d6d..b8455ea32 100644 --- a/crates/akita-pcs/examples/profile/modes.rs +++ b/crates/akita-pcs/examples/profile/modes.rs @@ -678,31 +678,6 @@ fn run_profile_onehot_fp128_d64_root_d128(nv: usize, num_polys: usize) { run_ring_dimension_transition(nv); return; } - // Per-matrix ring dimensions at the root: A = 128, with independently - // selected B/D dimensions. - // The complete D128 suffix is replanned from the resulting root witness. - if std::env::var("AKITA_PER_MATRIX_RING_DIMS_ROOT").as_deref() == Ok("1") { - let b_ring_dim: usize = std::env::var("AKITA_ROOT_B_RING_DIM") - .ok() - .and_then(|value| value.parse().ok()) - .unwrap_or(64); - let d_ring_dim: usize = std::env::var("AKITA_ROOT_D_RING_DIM") - .ok() - .and_then(|value| value.parse().ok()) - .unwrap_or(64); - tracing::info!( - "=== onehot_fp128_d64_root_d128 (fp128, {prime}, root d_a=128 / d_b={b_ring_dim} / d_d={d_ring_dim}, 1-of-{onehot_k}) ===" - ); - match (b_ring_dim, d_ring_dim) { - (64, 64) => run_per_matrix_ring_dims_root::<64, 64>(nv), - (128, 64) => run_per_matrix_ring_dims_root::<128, 64>(nv), - (64, 128) => run_per_matrix_ring_dims_root::<64, 128>(nv), - (o, p) => panic!( - "AKITA_ROOT_B_RING_DIM={o} / AKITA_ROOT_D_RING_DIM={p} unsupported (use 64 or 128, must divide 128)" - ), - } - return; - } let title = format!( "=== onehot_fp128_d64_root_d128 (fp128, {prime}, D={root_d} for folds [0,{switch}) then D=64, 1-of-{onehot_k}, log_commit_bound=1) ===" ); @@ -819,39 +794,6 @@ fn run_ring_dimension_transition_impl(nv: usize) { ); } -/// Run the per-matrix ring-dimension root experiment at A/B/D = -/// `128`/`B_RING_DIM`/`D_RING_DIM`, followed by a freshly planned D128 suffix. -#[cfg(all(not(feature = "profile-onehot-fp128-d64"), not(feature = "profile-ci")))] -fn run_per_matrix_ring_dims_root(nv: usize) { - use akita_pcs::test_support::PerMatrixRingDimsRootConfig; - type Cfg = PerMatrixRingDimsRootConfig; - let layout = resolve_layout::>(nv); - let required_vars = layout.position_index_bits() - + layout.block_index_bits() - + 128usize.trailing_zeros() as usize; - if required_vars > nv { - panic!( - "[onehot_fp128_d64_root_d128] per-matrix ring-dimension root requires {required_vars} variables, but AKITA_NUM_VARS={nv}" - ); - } - let plan = Cfg::::runtime_schedule(AkitaScheduleLookupKey::single( - PolynomialGroupLayout::singleton(nv), - )) - .expect("per-matrix ring-dimension root schedule"); - print_layout( - &layout, - 1, - Cfg::::decomposition().field_bits(), - ); - run_onehot::>( - "onehot_fp128_d64_root_d128", - nv, - &layout, - Some(&plan), - false, - ); -} - /// Run the mixed-D experiment: `Env` (ring dim `ROOT_D`) is the leading-band /// envelope, switching to `D64OneHot` after fold level `SWITCH_AT_FOLD - 1`. #[cfg(all(not(feature = "profile-onehot-fp128-d64"), not(feature = "profile-ci")))] diff --git a/specs/mixed-ring-dimension-per-level.md b/specs/mixed-ring-dimension-per-level.md index cd559b063..bdca1868f 100644 --- a/specs/mixed-ring-dimension-per-level.md +++ b/specs/mixed-ring-dimension-per-level.md @@ -582,11 +582,9 @@ The current benchmark makes the requested policy's result concrete: | B | **67,633,152** | 97,824 | **21.945 ms** | | E | **67,633,152** | 95,768 | **21.869 ms** | | F | 90,177,536 | 98,229 | 27.153 ms | -| C | 135,266,304 | 108,171 | 35.367 ms | -| D | **67,633,152** | 108,183 | 25.931 ms | -Under an unrestricted choice among only these seven predefined schedules, -`(setup field elements, proof bytes)` selects A′: it ties B/E/D on setup and +Under an unrestricted choice among only these five predefined schedules, +`(setup field elements, proof bytes)` selects A′: it ties B/E on setup and has the smallest proof among them. That historical comparison is not a correctness reference for the approved planner domain. The planner additionally enforces component-wise descent and returns to D64 at L2. It also searches block splits @@ -918,7 +916,7 @@ The planner integration is complete only when all of these hold: tampering, malformed dimensions, unsupported SIS cells, and setup under-capacity. 12. The `nv=36` constrained search completes, obeys all transition/rank caps, - and the complete A/A′/B/E/F/C/D benchmark matrix is rerun from one build. + and the complete A/A′/B/E/F benchmark matrix is rerun from one build. ### Required planner tests @@ -966,11 +964,15 @@ The labels below are local to this spec. | B | L0–L1 uniform D128, then uniform D64 (`switch = 2`) | | E | L0 `128/128/128`, L1 `128/64/64`, then uniform D64 | | F | L0 `512/128/128`, L1 `128/64/64`, then uniform D64 | -| C | root `128/64/64`, then a freshly planned uniform-D128 suffix | -| D | root `128/128/64`, then a freshly planned uniform-D128 suffix | +| P256-direct | L0 `256/128/128`, then uniform D64 | +| P256-three-band | L0 `256/128/128`, L1 `128/64/64`, then uniform D64 | -C and D are per-matrix-root experiments. They are not D64-tail variants and -must not be described as alternatives that share E's suffix policy. +`P256-direct` is the current nv=36 offline-planner shape. The stock profiler +does not expose that nv=36 row because the generated mixed-D runtime catalog +currently contains only nv=32; its measurement below used benchmark-only +wiring around the existing synthetic transition builder. `P256-three-band` is +directly selectable through the stock three-band profile with +`AKITA_THREE_BAND_ROOT_A_RING_DIM=256`. ## Current deterministic schedule snapshot @@ -988,8 +990,6 @@ elements gives the setup-vector byte footprint. | B | 7 | `128/128/128` | `3/1/1` | 157,319,424 | 528,384 @ D128 | 127,488 / 64 | | E | 7 | `128/128/128` | `3/1/1` | 157,319,424 | 528,384 @ D128 | 127,488 / 64 | | F | 7 | `512/128/128` | `1/1/1` | 247,552,000 | 176,128 @ D512 | 127,488 / 64 | -| C | 6 | `128/64/64` | `3/2/1` | 157,324,928 | 1,056,768 @ D128 | 155,648 / 128 | -| D | 6 | `128/128/64` | `3/1/1` | 157,319,424 | 528,384 @ D128 | 155,648 / 128 | Important transition rows: @@ -998,8 +998,6 @@ Important transition rows: | B | `128/128/128` | `3/1/1` | 5,644,288 | | E | `128/64/64` | `3/1/1` | 5,644,288 | | F | `128/64/64` | `3/2/1` | 6,323,968 | -| C | `128/128/128` | `3/1/1` | 5,644,288 | -| D | `128/128/128` | `3/1/1` | 5,644,288 | Exact root matrix input widths: @@ -1008,8 +1006,6 @@ Exact root matrix input widths: | A | 262,144 | 1,056,768 | 176,128 | | A′ / B / E | 131,072 | 528,384 | 176,128 | | F | 32,768 | 704,512 | 704,512 | -| C | 131,072 | 1,056,768 | 352,256 | -| D | 131,072 | 528,384 | 352,256 | The F widths are the key correction from the latest scheduler work. A D512 A source with D128 B/D matrices has four physical subcolumns per native column. @@ -1079,8 +1075,9 @@ Adapter: PerMatrixRingDimsRootConfig ``` -The suffix is uniform `Env::D`. With `Env = D128OneHot`, this produces C and D, -whose terminal remains D128. +The suffix is uniform `Env::D`. This builder remains test support for +per-matrix root geometry; it is no longer exposed as a standalone profile +benchmark. ### Multi-band transition: `ring_dimension_transition_schedule` @@ -1281,7 +1278,7 @@ Changes: `retarget_commitment_matrices`. - Made width derivation use the final A projection source. - Recomputed outgoing witness lengths after each retargeted level. -- Replanned C/D's complete D128 suffix. +- Replanned the per-matrix root builder's complete uniform suffix. - Replanned E/F's middle and D64 continuations at their exact boundaries. - Derived every adapter's setup envelope from its actual synthetic schedule. - Added schedule tests for: @@ -1300,7 +1297,7 @@ Review result: function. - The D512 promotion is now internally consistent, but still heuristic because the planner does not choose the D512 root geometry natively. -- Existing E/F/C/D benchmark provenance became ambiguous. This spec now marks +- Existing E/F benchmark provenance became ambiguous. This spec now marks it explicitly. ### `25a1e94a6` — name ring dimensions precisely @@ -1323,9 +1320,6 @@ Profile environment renames: | Old | Current | |---|---| -| `AKITA_MIXED_ROLE` | `AKITA_PER_MATRIX_RING_DIMS_ROOT` | -| `AKITA_MIXED_OUTER_D` | `AKITA_ROOT_B_RING_DIM` | -| `AKITA_MIXED_OPEN_D` | `AKITA_ROOT_D_RING_DIM` | | `AKITA_MIXED_ROLESWITCH` | `AKITA_RING_DIMENSION_TRANSITION` | | `AKITA_MIXED_ROLESWITCH_ROOT_D` | `AKITA_TRANSITION_ROOT_D_RING_DIM` | | `AKITA_MIXED_THREEBAND` | `AKITA_THREE_BAND_RING_DIMENSION_TRANSITION` | @@ -1373,7 +1367,44 @@ per-matrix coverage is `per_matrix_ring_dims_root_e2e.rs`. ## Benchmark status -### Results (nv = 36; after exact staged replanning; timings are 2-run means) +### Current-main rerun with D256 topologies + +The table below was measured on 2026-08-05 from `30e69d4d4d` on the same Apple +M4 Max MacBook Pro (16 cores, 64 GB), running macOS 26.6. The protocol matches +the historical table: default features, direct setup contributions, 16 Rayon +prove threads, 16 Rayon verify threads, tracing off, one discarded warmup, and +two sequential retained runs. With two samples, the reported median is their +arithmetic mean. + +| Profile / schedule | Root ranks `n_a/n_b/n_d` | Levels | Commit | Prove | Verify | Proof bytes | Physical setup fields | Setup vector / prover NTT cache | Peak RSS | +|---|---|---:|---:|---:|---:|---:|---:|---:|---:| +| A: uniform D64 | `6/2/1` | 9 | 23.261 s | 2.471 s | 31.411 ms | 93,395 | 135,266,304 | 2.16 GB / 5.41 GB | 11.72 GiB | +| A′: `128/128/128 → 64/64/64` | `3/1/1` | 9 | 13.999 s | 2.424 s | 21.431 ms | 94,417 | 67,633,152 | 1.08 GB / 5.41 GB | 10.66 GiB | +| B: two uniform-D128 levels, then D64 | `3/1/1` | 7 | 15.206 s | 2.476 s | 19.632 ms | 97,810 | 67,633,152 | 1.08 GB / 5.41 GB | 10.66 GiB | +| E: `128/128/128 → 128/64/64 → 64/64/64` | `3/1/1` | 7 | 16.002 s | **2.381 s** | 20.071 ms | 95,760 | 67,633,152 | 1.08 GB / 5.41 GB | 10.65 GiB | +| **P256-direct: `256/128/128 → 64/64/64`** | **`1/1/1`** | 9 | 9.143 s | 2.838 s | 18.143 ms | 94,418 | **45,088,768** | **0.72 GB / 5.41 GB** | 10.22 GiB | +| **P256-three-band: `256/128/128 → 128/64/64 → 64/64/64`** | **`1/1/1`** | 7 | **8.454 s** | 2.598 s | **16.373 ms** | 95,737 | **45,088,768** | **0.72 GB / 5.41 GB** | **10.20 GiB** | + +Both D256 topologies attain rank one for A. Relative to D128, they reduce the +physical setup objective from 67,633,152 to 45,088,768 fp128 field elements, +a 33.3% reduction. The three-band topology also removes two fold levels +relative to the direct-D64 suffix and was the faster measured D256 variant. + +The current D512 F profile is not included as a successful timing row. It now +fails during schedule selection with a catalog/SIS identity mismatch after +commit. Before failure it used 90,177,536 physical setup fields, a 1.44 GB +setup vector, a 10.82 GB reported prover NTT cache, and approximately 18.19 +GiB peak RSS. Since D256 already gives A rank one with half that physical setup, +the current measurements provide no rank or setup rationale for D512. + +The stock nv=36 profiler also currently materializes `2^28` high Lagrange +weights and exceeds the `2^25` sequence limit before setup. For this rerun only, +the public one-hot opening was computed with the existing streaming opening +kernel before the timed phases. The diagnostic edit was removed after the +measurements and did not change schedule construction, prove, verify, or proof +serialization. + +### Historical results (nv = 36; after exact staged replanning; timings are 2-run means) All columns below were measured on 2026-07-28 from one release build of `25a1e94a6`. The host was an Apple M4 Max MacBook Pro (16 cores, 64 GB) running @@ -1382,18 +1413,18 @@ contributions, 16 Rayon prove threads, 16 Rayon verify threads, tracing off, one discarded warmup, and two sequential measured runs per column. With two samples, the harness median is also their arithmetic mean. -| Metric | A: `D = 64` all | A′: `D = 128` root only (`switch = 1`) | B: `D = 128` L0–L1 (`switch = 2`) | E: `128/128/128 → 128/64/64 → 64` | F: `512/128/128 → 128/64/64 → 64` | C: root `128/64/64` | D: root `128/128/64` | -|---|---:|---:|---:|---:|---:|---:|---:| -| Commit | 22.61 s | 13.58 s | 13.75 s | 13.52 s | **10.17 s** | 13.79 s | 13.42 s | -| Prove | 2.921 s | 3.308 s | 3.076 s | **3.047 s** | 4.656 s | 3.189 s | 3.159 s | -| Verify | 0.0362 s | 0.0277 s | 0.0219 s | **0.0219 s** | 0.0272 s | 0.0354 s | 0.0259 s | -| Proof bytes | **93,400** | 94,428 | 97,824 | 95,768 | 98,229 | 108,171 | 108,183 | -| Fold / terminal bytes | 41,012 / 52,388 | 42,036 / 52,392 | 34,956 / 62,868 | 32,908 / 62,860 | 35,372 / 62,857 | 35,672 / 72,499 | 35,672 / 72,511 | -| Setup vector / prover NTT cache | 2.16 GB / 5.41 GB | 1.08 GB / 2.71 GB | 1.08 GB / 2.71 GB | 1.08 GB / 2.71 GB | 1.44 GB / 3.61 GB | 2.16 GB / 5.41 GB | 1.08 GB / 2.71 GB | -| Verifier NTT cache | 1.44 MB | 1.44 MB | 1.44 MB | 1.44 MB | 1.44 MB | 1.44 MB | 1.44 MB | -| Peak RSS | 11.40 GiB | 10.45 GiB | 10.32 GiB | 10.34 GiB | 20.48 GiB | 16.51 GiB | 10.47 GiB | -| Root ranks `n_a/n_b/n_d` | `6/2/1` | `3/1/1` | `3/1/1` | `3/1/1` | `1/1/1` | `3/2/1` | `3/1/1` | -| Fold levels, including terminal | 9 | 9 | 7 | 7 | 7 | 6 | 6 | +| Metric | A: `D = 64` all | A′: `D = 128` root only (`switch = 1`) | B: `D = 128` L0–L1 (`switch = 2`) | E: `128/128/128 → 128/64/64 → 64` | F: `512/128/128 → 128/64/64 → 64` | +|---|---:|---:|---:|---:|---:| +| Commit | 22.61 s | 13.58 s | 13.75 s | 13.52 s | **10.17 s** | +| Prove | 2.921 s | 3.308 s | 3.076 s | **3.047 s** | 4.656 s | +| Verify | 0.0362 s | 0.0277 s | 0.0219 s | **0.0219 s** | 0.0272 s | +| Proof bytes | **93,400** | 94,428 | 97,824 | 95,768 | 98,229 | +| Fold / terminal bytes | 41,012 / 52,388 | 42,036 / 52,392 | 34,956 / 62,868 | 32,908 / 62,860 | 35,372 / 62,857 | +| Setup vector / prover NTT cache | 2.16 GB / 5.41 GB | 1.08 GB / 2.71 GB | 1.08 GB / 2.71 GB | 1.08 GB / 2.71 GB | 1.44 GB / 3.61 GB | +| Verifier NTT cache | 1.44 MB | 1.44 MB | 1.44 MB | 1.44 MB | 1.44 MB | +| Peak RSS | 11.40 GiB | 10.45 GiB | 10.32 GiB | 10.34 GiB | 20.48 GiB | +| Root ranks `n_a/n_b/n_d` | `6/2/1` | `3/1/1` | `3/1/1` | `3/1/1` | `1/1/1` | +| Fold levels, including terminal | 9 | 9 | 7 | 7 | 7 | The two retained timing samples were: @@ -1404,12 +1435,10 @@ The two retained timing samples were: | B | 13.7369 s, 13.7621 s | 3.0878 s, 3.0644 s | 22.000 ms, 21.891 ms | | E | 13.6481 s, 13.3853 s | 3.0292 s, 3.0643 s | 21.972 ms, 21.766 ms | | F | 10.1663 s, 10.1765 s | 4.7063 s, 4.6053 s | 27.240 ms, 27.067 ms | -| C | 13.7317 s, 13.8389 s | 3.1873 s, 3.1916 s | 35.359 ms, 35.374 ms | -| D | 13.4459 s, 13.3866 s | 3.1818 s, 3.1368 s | 25.704 ms, 26.157 ms | #### Follow-up reproduction after planner-native mixed-D cut -The full seven-profile matrix was rerun from `8d7598fff` on 2026-07-28 after +The full five-profile matrix was rerun from `8d7598fff` on 2026-07-28 after adding the opt-in per-matrix planner search. The build, host, direct setup mode, thread counts, warmup count, and retained-run count matched the protocol above. @@ -1423,18 +1452,18 @@ Every deterministic result reproduced exactly: The follow-up measurements were: -| Metric | A: `D = 64` all | A′: `D = 128` root only | B: `D = 128` L0–L1 | E: `128/128/128 → 128/64/64 → 64` | F: `512/128/128 → 128/64/64 → 64` | C: root `128/64/64` | D: root `128/128/64` | -|---|---:|---:|---:|---:|---:|---:|---:| -| Commit | 23.410 s | 13.885 s | 13.790 s | 15.996 s | **11.241 s** | 14.782 s | 14.617 s | -| Prove | 2.972 s | 3.335 s | **3.091 s** | 3.125 s | 4.894 s | 3.232 s | 3.241 s | -| Verify | 0.0360 s | 0.0271 s | **0.0212 s** | 0.0223 s | 0.0281 s | 0.0368 s | 0.0273 s | -| Proof bytes | **93,400** | 94,428 | 97,824 | 95,768 | 98,229 | 108,171 | 108,183 | -| Fold / terminal bytes | 41,012 / 52,388 | 42,036 / 52,392 | 34,956 / 62,868 | 32,908 / 62,860 | 35,372 / 62,857 | 35,672 / 72,499 | 35,672 / 72,511 | -| Setup vector / prover NTT cache | 2.16 GB / 5.41 GB | 1.08 GB / 2.71 GB | 1.08 GB / 2.71 GB | 1.08 GB / 2.71 GB | 1.44 GB / 3.61 GB | 2.16 GB / 5.41 GB | 1.08 GB / 2.71 GB | -| Verifier NTT cache | 1.44 MB | 1.44 MB | 1.44 MB | 1.44 MB | 1.44 MB | 1.44 MB | 1.44 MB | -| Peak RSS | 11.40 GiB | 10.46 GiB | 10.32 GiB | 10.32 GiB | 20.54 GiB | 16.51 GiB | 10.35 GiB | -| Root ranks `n_a/n_b/n_d` | `6/2/1` | `3/1/1` | `3/1/1` | `3/1/1` | `1/1/1` | `3/2/1` | `3/1/1` | -| Fold levels, including terminal | 9 | 9 | 7 | 7 | 7 | 6 | 6 | +| Metric | A: `D = 64` all | A′: `D = 128` root only | B: `D = 128` L0–L1 | E: `128/128/128 → 128/64/64 → 64` | F: `512/128/128 → 128/64/64 → 64` | +|---|---:|---:|---:|---:|---:| +| Commit | 23.410 s | 13.885 s | 13.790 s | 15.996 s | **11.241 s** | +| Prove | 2.972 s | 3.335 s | **3.091 s** | 3.125 s | 4.894 s | +| Verify | 0.0360 s | 0.0271 s | **0.0212 s** | 0.0223 s | 0.0281 s | +| Proof bytes | **93,400** | 94,428 | 97,824 | 95,768 | 98,229 | +| Fold / terminal bytes | 41,012 / 52,388 | 42,036 / 52,392 | 34,956 / 62,868 | 32,908 / 62,860 | 35,372 / 62,857 | +| Setup vector / prover NTT cache | 2.16 GB / 5.41 GB | 1.08 GB / 2.71 GB | 1.08 GB / 2.71 GB | 1.08 GB / 2.71 GB | 1.44 GB / 3.61 GB | +| Verifier NTT cache | 1.44 MB | 1.44 MB | 1.44 MB | 1.44 MB | 1.44 MB | +| Peak RSS | 11.40 GiB | 10.46 GiB | 10.32 GiB | 10.32 GiB | 20.54 GiB | +| Root ranks `n_a/n_b/n_d` | `6/2/1` | `3/1/1` | `3/1/1` | `3/1/1` | `1/1/1` | +| Fold levels, including terminal | 9 | 9 | 7 | 7 | 7 | The retained samples were: @@ -1445,13 +1474,11 @@ The retained samples were: | B | 13.7956 s, 13.7841 s | 3.0777 s, 3.1044 s | 21.368 ms, 21.040 ms | | E | 15.1230 s, 16.8683 s | 3.1357 s, 3.1144 s | 22.806 ms, 21.712 ms | | F | 11.3390 s, 11.1421 s | 4.8520 s, 4.9355 s | 27.898 ms, 28.230 ms | -| C | 14.7149 s, 14.8497 s | 3.2271 s, 3.2359 s | 36.907 ms, 36.597 ms | -| D | 14.5899 s, 14.6444 s | 3.2066 s, 3.2750 s | 26.843 ms, 27.731 ms | Relative to the earlier idle-machine table, prove changed by `+0.5%` to -`+5.1%` and verify by `-3.4%` to `+5.2%`. Commit was more sensitive to host -state: A/A′/B changed by only `+0.3%` to `+3.5%`, while the later E/F/C/D -runs were `+7.2%` to `+18.3%`. E's two commit samples alone differed by +`+5.1%` and verify by `-3.4%` to `+3.5%`. Commit was more sensitive to host +state: A/A′/B changed by only `+0.3%` to `+3.5%`, while the later E/F +runs were `+10.5%` to `+18.3%`. E's two commit samples alone differed by 11.5%, while its proof geometry and prove/verify times remained stable. An independent E repeat after the matrix measured 14.282 s commit, 3.092 s prove, and 22.649 ms verify, reducing its commit delta from `+18.3%` to @@ -1654,26 +1681,6 @@ AKITA_THREE_BAND_ROOT_A_RING_DIM=512 \ AKITA_PROFILE_TRACE=0 \ AKITA_PROFILE_LOG=info \ cargo run --release -p akita-pcs --example profile - -# C: root 128/64/64, then uniform D128 -AKITA_NUM_VARS=36 \ -AKITA_MODE=onehot_fp128_d64_root_d128 \ -AKITA_PER_MATRIX_RING_DIMS_ROOT=1 \ -AKITA_ROOT_B_RING_DIM=64 \ -AKITA_ROOT_D_RING_DIM=64 \ -AKITA_PROFILE_TRACE=0 \ -AKITA_PROFILE_LOG=info \ -cargo run --release -p akita-pcs --example profile - -# D: root 128/128/64, then uniform D128 -AKITA_NUM_VARS=36 \ -AKITA_MODE=onehot_fp128_d64_root_d128 \ -AKITA_PER_MATRIX_RING_DIMS_ROOT=1 \ -AKITA_ROOT_B_RING_DIM=128 \ -AKITA_ROOT_D_RING_DIM=64 \ -AKITA_PROFILE_TRACE=0 \ -AKITA_PROFILE_LOG=info \ -cargo run --release -p akita-pcs --example profile ``` Reproduce the recursive controls with the CI profiler build: From 563af0d770f9a7336c3ffb2012a70663edc311b8 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Thu, 6 Aug 2026 07:30:49 -0700 Subject: [PATCH 02/24] feat(planner): add declarative adaptive ring dimensions --- crates/akita-config/src/lib.rs | 28 +- .../src/precommitted_commitment.rs | 10 +- crates/akita-config/src/proof_optimized.rs | 18 +- .../akita-config/src/proof_optimized/fp128.rs | 29 +- .../akita-config/src/recursive_commitment.rs | 7 +- crates/akita-config/tests/generated_tables.rs | 35 +- crates/akita-config/tests/runtime_fallback.rs | 15 +- crates/akita-pcs/src/test_support.rs | 24 +- .../examples/mixed_dimension_search.rs | 27 +- crates/akita-planner/src/emit/mod.rs | 74 +- .../akita-planner/src/generated_families.rs | 5 +- crates/akita-planner/src/group_batch.rs | 17 +- crates/akita-planner/src/lib.rs | 10 +- crates/akita-planner/src/schedule_params.rs | 343 ++--- .../src/schedule_params/candidate.rs | 6 +- .../schedule_params/candidate/recursive.rs | 49 +- .../src/schedule_params/mixed_search.rs | 117 +- .../src/schedule_params/suffix_dp.rs | 4 +- .../src/schedule_params/tests.rs | 841 ++++------- .../src/schedule_params/unpruned_search.rs | 117 +- crates/akita-schedules/src/candidate.rs | 156 ++- .../akita-schedules/src/catalog_identity.rs | 170 ++- .../src/generated/fp128_d256_onehot.rs | 8 +- crates/akita-schedules/src/generated/mod.rs | 153 +- crates/akita-schedules/src/lib.rs | 4 +- crates/akita-schedules/src/runtime.rs | 189 ++- specs/declarative-ring-dimension-policy.md | 1235 +++++++++++++++++ specs/mixed-ring-dimension-per-level.md | 207 +-- ...ursive-mixed-ring-dimension-performance.md | 28 +- 29 files changed, 2560 insertions(+), 1366 deletions(-) create mode 100644 specs/declarative-ring-dimension-policy.md diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index 507e27ea7..2c429bb0c 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -10,15 +10,15 @@ use akita_challenges::{SparseChallengeConfig, TensorChallengeShape}; 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::{ - AkitaScheduleInputs, AkitaScheduleLookupKey, ChunkedWitnessCfg, CommitmentRingDims, - CommittedGroupParams, DecompositionParams, FoldSchedule, OpeningClaimsLayout, - SetupMatrixEnvelope, SisModulusProfileId, + AkitaScheduleInputs, AkitaScheduleLookupKey, ChunkedWitnessCfg, CommittedGroupParams, + DecompositionParams, FoldSchedule, OpeningClaimsLayout, SetupMatrixEnvelope, + SisModulusProfileId, }; /// Define a multi-chunk companion preset that delegates every layout-affecting @@ -35,8 +35,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 { @@ -128,13 +128,12 @@ pub fn policy_of() -> PlannerPolicy { cost_model: akita_schedules::PlannerCostModelId::ExactPayloadAndSetupEnvelope, selection_policy: akita_schedules::SelectionPolicyId::for_policy( recursive_setup_planning, - Cfg::D, - Cfg::RING_DIMENSION_CANDIDATES, + Cfg::RING_DIMENSION_SCHEDULE_MODE, ), max_setup_envelope_field_elements: akita_types::MAX_SETUP_MATRIX_FIELD_ELEMENTS, min_offloaded_witness_contraction: 3, ring_dimension: Cfg::D, - 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, @@ -202,12 +201,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; diff --git a/crates/akita-config/src/precommitted_commitment.rs b/crates/akita-config/src/precommitted_commitment.rs index ba6cd67cf..97c809019 100644 --- a/crates/akita-config/src/precommitted_commitment.rs +++ b/crates/akita-config/src/precommitted_commitment.rs @@ -10,10 +10,9 @@ use crate::{policy_of, CommitmentConfig}; use akita_challenges::{SparseChallengeConfig, TensorChallengeShape}; use akita_field::AkitaError; use akita_types::{ - accumulate_matrix_field_elements_for_level, AkitaScheduleInputs, CommitmentRingDims, - CommittedGroupParams, CommittedGroupProfile, DecompositionParams, FoldSchedule, - OpenCommitMatrixParams, OpeningClaimsLayout, PolynomialGroupLayout, SetupMatrixEnvelope, - SisModulusProfileId, + accumulate_matrix_field_elements_for_level, AkitaScheduleInputs, CommittedGroupParams, + CommittedGroupProfile, DecompositionParams, FoldSchedule, OpenCommitMatrixParams, + OpeningClaimsLayout, PolynomialGroupLayout, SetupMatrixEnvelope, SisModulusProfileId, }; use std::marker::PhantomData; @@ -27,7 +26,8 @@ impl CommitmentConfig for PrecommittedCommitmentConfig DecompositionParams { Cfg::decomposition() diff --git a/crates/akita-config/src/proof_optimized.rs b/crates/akita-config/src/proof_optimized.rs index 7fbb7334b..1174d4300 100644 --- a/crates/akita-config/src/proof_optimized.rs +++ b/crates/akita-config/src/proof_optimized.rs @@ -393,9 +393,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); @@ -403,16 +403,16 @@ 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)) => { impl_proof_optimized_preset!(@core $cfg, $field, $ext_field, $family, $d, $field_bits, $log_commit_bound, $fold_norms, table, $feat, $family_name, $table); }; - ($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); }; - (@core $cfg:ident, $field:ty, $ext_field:ty, $family:expr, $d:expr, $field_bits:expr, $log_commit_bound:expr, $fold_norms:expr, none $(, ring_dimension_candidates = $candidates:expr)?) => { + (@core $cfg:ident, $field:ty, $ext_field:ty, $family:expr, $d:expr, $field_bits:expr, $log_commit_bound:expr, $fold_norms:expr, none $(, ring_dimension_schedule_mode = $mode:expr)?) => { impl $crate::CommitmentConfig for $cfg { type Field = $field; type ExtField = $ext_field; const D: usize = $d; - impl_proof_optimized_preset!(@ring_dimension_candidates $($candidates)?); + impl_proof_optimized_preset!(@ring_dimension_schedule_mode $($mode)?); fn decomposition() -> akita_types::DecompositionParams { akita_types::DecompositionParams { @@ -483,13 +483,13 @@ macro_rules! impl_proof_optimized_preset { impl_proof_optimized_preset!(@schedule_catalog none); } }; - (@core $cfg:ident, $field:ty, $ext_field:ty, $family:expr, $d:expr, $field_bits:expr, $log_commit_bound:expr, $fold_norms:expr, table, $feat:literal, $family_name:literal, $table:ident $(, ring_dimension_candidates = $candidates:expr)?) => { + (@core $cfg:ident, $field:ty, $ext_field:ty, $family:expr, $d:expr, $field_bits:expr, $log_commit_bound:expr, $fold_norms:expr, table, $feat:literal, $family_name:literal, $table:ident $(, ring_dimension_schedule_mode = $mode:expr)?) => { impl $crate::CommitmentConfig for $cfg { type Field = $field; type ExtField = $ext_field; const D: usize = $d; - impl_proof_optimized_preset!(@ring_dimension_candidates $($candidates)?); + impl_proof_optimized_preset!(@ring_dimension_schedule_mode $($mode)?); fn decomposition() -> akita_types::DecompositionParams { akita_types::DecompositionParams { diff --git a/crates/akita-config/src/proof_optimized/fp128.rs b/crates/akita-config/src/proof_optimized/fp128.rs index 301503daf..39b050002 100644 --- a/crates/akita-config/src/proof_optimized/fp128.rs +++ b/crates/akita-config/src/proof_optimized/fp128.rs @@ -40,21 +40,12 @@ pub struct D256OneHot; pub struct MixedDimFp128OneHot; 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, - }, - ]; + /// A dimensions searched at the two adaptive leading levels. + pub const A_RING_DIMENSIONS: [usize; 3] = [64, 128, 256]; + /// B dimensions scanned by minimum secure rank for each A candidate. + pub const B_RING_DIMENSIONS: [usize; 2] = [64, 128]; + /// D dimensions scanned by minimum secure rank for each A candidate. + pub const D_RING_DIMENSIONS: [usize; 2] = [64, 128]; } /// Tableless policy marker for a `D = 512` inner (A-role) root. @@ -182,7 +173,13 @@ impl_proof_optimized_preset!( "fp128_mixed_dim_onehot", fp128_mixed_dim_onehot_table ), - ring_dimension_candidates = &MixedDimFp128OneHot::RING_DIMENSION_CANDIDATES + ring_dimension_schedule_mode = akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels: 2, + uniform_suffix_dimension: 64, + potential_a_dimensions: &MixedDimFp128OneHot::A_RING_DIMENSIONS, + potential_b_dimensions: &MixedDimFp128OneHot::B_RING_DIMENSIONS, + potential_d_dimensions: &MixedDimFp128OneHot::D_RING_DIMENSIONS, + } ); impl_proof_optimized_preset!( D512OneHot, diff --git a/crates/akita-config/src/recursive_commitment.rs b/crates/akita-config/src/recursive_commitment.rs index ddf6df207..f010410c8 100644 --- a/crates/akita-config/src/recursive_commitment.rs +++ b/crates/akita-config/src/recursive_commitment.rs @@ -4,8 +4,8 @@ use crate::CommitmentConfig; use akita_challenges::{SparseChallengeConfig, TensorChallengeShape}; use akita_field::AkitaError; use akita_types::{ - AkitaScheduleInputs, ChunkedWitnessCfg, CommitmentRingDims, DecompositionParams, FoldSchedule, - OpeningClaimsLayout, SetupMatrixEnvelope, SisModulusProfileId, SETUP_OFFLOAD_D_SETUP, + AkitaScheduleInputs, ChunkedWitnessCfg, DecompositionParams, FoldSchedule, OpeningClaimsLayout, + SetupMatrixEnvelope, SisModulusProfileId, SETUP_OFFLOAD_D_SETUP, }; #[cfg(any( feature = "schedules-fp128-d64-onehot-recursive", @@ -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() diff --git a/crates/akita-config/tests/generated_tables.rs b/crates/akita-config/tests/generated_tables.rs index 7ba4ee1a4..e46d804d0 100644 --- a/crates/akita-config/tests/generated_tables.rs +++ b/crates/akita-config/tests/generated_tables.rs @@ -279,20 +279,8 @@ 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, - }, - ]; +fn mixed_catalog_identity_binds_nonwinning_a_dimensions() { + static WITHOUT_NONWINNER: &[usize] = &[64, 256]; let policy = policy_of::(); let catalog = fp128::MixedDimFp128OneHot::schedule_catalog().expect("mixed catalog"); @@ -305,7 +293,24 @@ fn mixed_catalog_identity_binds_nonwinning_candidate_tuples() { != 128)); let mut mutated = catalog; - mutated.identity.ring_dimension_candidates = WITHOUT_NONWINNER; + 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, diff --git a/crates/akita-config/tests/runtime_fallback.rs b/crates/akita-config/tests/runtime_fallback.rs index f5d27cd64..db5834775 100644 --- a/crates/akita-config/tests/runtime_fallback.rs +++ b/crates/akita-config/tests/runtime_fallback.rs @@ -305,15 +305,15 @@ fn recursive_adapter_delegates_scalar_keys_to_the_ordinary_catalog() { } #[test] -fn adapters_forward_ring_dimension_candidates() { +fn adapters_forward_ring_dimension_schedule_mode() { type Base = fp128::MixedDimFp128OneHot; 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, ); } @@ -323,13 +323,12 @@ fn assert_policy_matches_cfg() { cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, selection_policy: SelectionPolicyId::for_policy( Cfg::recursive_setup_planning(), - Cfg::D, - Cfg::RING_DIMENSION_CANDIDATES, + Cfg::RING_DIMENSION_SCHEDULE_MODE, ), max_setup_envelope_field_elements: akita_types::MAX_SETUP_MATRIX_FIELD_ELEMENTS, min_offloaded_witness_contraction: 3, ring_dimension: Cfg::D, - 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, diff --git a/crates/akita-pcs/src/test_support.rs b/crates/akita-pcs/src/test_support.rs index 8ff882110..df96ebef2 100644 --- a/crates/akita-pcs/src/test_support.rs +++ b/crates/akita-pcs/src/test_support.rs @@ -40,8 +40,6 @@ enum SyntheticScheduleKind { RecursiveRingDimensionTransition, } -const D256_PLANNER_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims::uniform(256)]; - #[derive(Clone, Debug, PartialEq, Eq)] struct SyntheticScheduleCacheKey { kind: SyntheticScheduleKind, @@ -363,8 +361,6 @@ where )); } let envelope_policy = policy_of::(); - let envelope_domain = - akita_planner::RingDimensionSearchDomain::uniform(envelope_policy.ring_dimension)?; let envelope_key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::new( num_vars, num_polynomials, @@ -373,7 +369,6 @@ where envelope_key.final_group, &envelope_policy, EnvelopeCfg::root_honest_fold_policy(), - &envelope_domain, EnvelopeCfg::ring_challenge_config, EnvelopeCfg::fold_challenge_shape_at_level, )? @@ -597,8 +592,6 @@ pub fn per_matrix_ring_dims_root_schedule( }, || { let root_policy = policy_of::(); - let root_domain = - akita_planner::RingDimensionSearchDomain::uniform(root_policy.ring_dimension)?; let root_key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::new( num_vars, num_polynomials, @@ -607,7 +600,6 @@ pub fn per_matrix_ring_dims_root_schedule( root_key.final_group, &root_policy, Env::root_honest_fold_policy(), - &root_domain, Env::ring_challenge_config, Env::fold_challenge_shape_at_level, )? @@ -1016,10 +1008,12 @@ where let mut root_policy = policy_of::(); let planned_root_d = if Root::D == 512 { 256 } else { Root::D }; if Root::D != planned_root_d { - root_policy.ring_dimension_candidates = D256_PLANNER_CANDIDATES; + root_policy.ring_dimension_schedule_mode = + akita_planner::RingDimensionScheduleMode::UniformDimension { + ring_dimension: planned_root_d, + }; } root_policy.ring_dimension = planned_root_d; - let root_domain = akita_planner::RingDimensionSearchDomain::uniform(planned_root_d)?; let root_key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::new( num_vars, num_polynomials, @@ -1028,7 +1022,6 @@ where root_key.final_group, &root_policy, Root::root_honest_fold_policy(), - &root_domain, Root::ring_challenge_config, Root::fold_challenge_shape_at_level, )? @@ -1379,11 +1372,10 @@ where type ExtField = Env::ExtField; const D: usize = Env::D; - const RING_DIMENSION_CANDIDATES: &'static [CommitmentRingDims] = &[CommitmentRingDims { - inner: Env::D, - outer: B_RING_DIM, - opening: D_RING_DIM, - }]; + const RING_DIMENSION_SCHEDULE_MODE: akita_planner::RingDimensionScheduleMode = + akita_planner::RingDimensionScheduleMode::UniformDimension { + ring_dimension: Env::D, + }; fn decomposition() -> DecompositionParams { Env::decomposition() diff --git a/crates/akita-planner/examples/mixed_dimension_search.rs b/crates/akita-planner/examples/mixed_dimension_search.rs index 6c41a7f6f..c9a5f5fe6 100644 --- a/crates/akita-planner/examples/mixed_dimension_search.rs +++ b/crates/akita-planner/examples/mixed_dimension_search.rs @@ -3,7 +3,7 @@ use akita_config::{ proof_optimized::fp128::{D64OneHot, MixedDimFp128OneHot}, CommitmentConfig, RecursiveCommitmentConfig, }; -use akita_planner::{find_group_batch_schedule, find_schedule, RingDimensionSearchDomain}; +use akita_planner::{find_group_batch_schedule, find_schedule}; use akita_types::{AkitaScheduleLookupKey, CommittedGroupProfile, PolynomialGroupLayout}; fn print_schedule( @@ -85,15 +85,10 @@ fn main() -> Result<(), akita_field::AkitaError> { .unwrap_or(36); let direct_policy = policy_of::(); let direct_key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::singleton(num_vars)); - let direct_domain = RingDimensionSearchDomain::new( - direct_policy.ring_dimension, - direct_policy.ring_dimension_candidates.iter().copied(), - )?; let direct = find_schedule( direct_key.final_group, &direct_policy, MixedDimFp128OneHot::root_honest_fold_policy(), - &direct_domain, MixedDimFp128OneHot::ring_challenge_config, MixedDimFp128OneHot::fold_challenge_shape_at_level, )?; @@ -106,18 +101,11 @@ fn main() -> Result<(), akita_field::AkitaError> { type MixedRecursive = RecursiveCommitmentConfig; let mixed_recursive_policy = policy_of::(); let mixed_recursive_key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::new(32, 2)); - let recursive_domain = RingDimensionSearchDomain::new( - mixed_recursive_policy.ring_dimension, - mixed_recursive_policy - .ring_dimension_candidates - .iter() - .copied(), - )?; - let mixed_recursive = find_schedule( - mixed_recursive_key.final_group, - &mixed_recursive_policy, + let mixed_recursive = find_group_batch_schedule( + &mixed_recursive_key, MixedRecursive::root_honest_fold_policy(), - &recursive_domain, + &[], + &mixed_recursive_policy, MixedRecursive::ring_challenge_config, MixedRecursive::fold_challenge_shape_at_level, )?; @@ -134,15 +122,10 @@ fn main() -> Result<(), akita_field::AkitaError> { let precommit_layout = PolynomialGroupLayout::singleton(16); let precommit_key = AkitaScheduleLookupKey::single(precommit_layout); let precommit_policy = policy_of::(); - let precommit_domain = RingDimensionSearchDomain::new( - precommit_policy.ring_dimension, - precommit_policy.ring_dimension_candidates.iter().copied(), - )?; let precommit = find_schedule( precommit_key.final_group, &precommit_policy, D64OneHot::root_honest_fold_policy(), - &precommit_domain, D64OneHot::ring_challenge_config, D64OneHot::fold_challenge_shape_at_level, )?; diff --git a/crates/akita-planner/src/emit/mod.rs b/crates/akita-planner/src/emit/mod.rs index f51d7d5e4..a22f44ef9 100644 --- a/crates/akita-planner/src/emit/mod.rs +++ b/crates/akita-planner/src/emit/mod.rs @@ -519,19 +519,57 @@ 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!( + concat!( + "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 }}" + ), + num_search_levels = num_search_levels, + uniform_suffix_dimension = uniform_suffix_dimension, + ), + ) + } + }; let ring_dims: String = identity .ring_dimensions .iter() @@ -540,8 +578,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", @@ -565,14 +602,15 @@ fn emit_identity_const(identity: &GeneratedScheduleCatalogIdentity) -> String { " witness_chunk: {witness_chunk},\n", " recursive_setup_planning: {recursive_setup_planning},\n", " root_fold_shape: {root_fold_shape},\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, @@ -719,7 +757,7 @@ pub fn emit_family_module(spec: &EmitSpec) -> Result { GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, \ CommitmentRingDims, PlannerCostModelId, PolynomialGroupLayout, CommittedGroupProfile, \ InnerCommitMatrixParams, OuterCommitMatrixParams, \ - SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, \ + RingDimensionScheduleMode, SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, \ TensorChallengeShape,\n}};" ) .map_err(|e| e.to_string())?; diff --git a/crates/akita-planner/src/generated_families.rs b/crates/akita-planner/src/generated_families.rs index 957a82e48..1c677bc71 100644 --- a/crates/akita-planner/src/generated_families.rs +++ b/crates/akita-planner/src/generated_families.rs @@ -19,7 +19,7 @@ use std::{ use crate::{ derive_standalone_precommit_profile, find_group_batch_schedule, find_schedule, - runtime_schedule_key_cmp, EmitSpec, PlannerPolicy, RingDimensionSearchDomain, + runtime_schedule_key_cmp, EmitSpec, PlannerPolicy, }; use akita_challenges::{SparseChallengeConfig, TensorChallengeShape}; use akita_field::AkitaError; @@ -186,13 +186,10 @@ fn regen(key: PolynomialGroupLayout) -> Result Result { type Cfg = fp128::MixedDimFp128OneHot; let policy = policy_of::(); - let dimensions = - RingDimensionSearchDomain::new(policy.ring_dimension, Cfg::RING_DIMENSION_CANDIDATES)?; Ok(find_schedule( key, &policy, honest_fold_policy_of::(), - &dimensions, Cfg::ring_challenge_config, Cfg::fold_challenge_shape_at_level, )? diff --git a/crates/akita-planner/src/group_batch.rs b/crates/akita-planner/src/group_batch.rs index d93ce6479..ea8ed0177 100644 --- a/crates/akita-planner/src/group_batch.rs +++ b/crates/akita-planner/src/group_batch.rs @@ -569,19 +569,24 @@ fn find_group_batch_schedule_inner( setup_field_budget: Option, ) -> Result { key.validate(policy.decomposition.field_bits())?; + if !key.precommitteds.is_empty() + && matches!( + policy.ring_dimension_schedule_mode, + crate::RingDimensionScheduleMode::AdaptiveDimension { .. } + ) + { + return Err(AkitaError::InvalidSetup( + "adaptive dimension search does not support multi-group roots".to_string(), + )); + } if key.precommitteds.is_empty() { // Genuine multi-group roots only. Empty-precommit keys are scalar and // must not enter recursion-enabled grouped planning. let scalar_policy = policy.direct_only(); - let dimensions = crate::schedule_params::RingDimensionSearchDomain::new( - scalar_policy.ring_dimension, - scalar_policy.ring_dimension_candidates.iter().copied(), - )?; return find_schedule( key.final_group, &scalar_policy, final_honest_fold_policy, - &dimensions, ring_challenge_config, fold_challenge_shape_at_level, ); @@ -630,7 +635,7 @@ fn find_group_batch_schedule_inner( candidate.total_bytes, ) }), - crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload => { + crate::SelectionPolicyId::MinAdaptiveARankDimensionThenSetupAndProof => { return Err(AkitaError::UnsupportedSchedule( "mixed ring-dimension selection is not supported for multi-group roots".to_string(), )); diff --git a/crates/akita-planner/src/lib.rs b/crates/akita-planner/src/lib.rs index 1a81ec938..ac4d0cc59 100644 --- a/crates/akita-planner/src/lib.rs +++ b/crates/akita-planner/src/lib.rs @@ -7,8 +7,7 @@ //! `fold_challenge_shape_at_level` closure pair, so the planner names no `CommitmentConfig` //! types and depends only on `akita-schedules` / `akita-types` / //! `akita-challenges` / `akita-field`. -//! [`RingDimensionSearchDomain`] is an explicit input for both uniform and -//! mixed planning. +//! Uniform and adaptive dimension domains are carried by [`RingDimensionScheduleMode`]. //! //! With the `catalog-gen` feature enabled, this crate also owns the offline //! generated-table family list and `gen_schedule_tables` binary. That feature @@ -16,8 +15,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; @@ -41,7 +41,7 @@ pub use emit::{ pub use group_batch::find_group_batch_schedule; pub use schedule_params::{ derive_standalone_precommit_profile, find_schedule, plan_optimal_suffix, suffix_opening_layout, - PlannedSuffix, PlannedSuffixFold, PlannedSuffixTerminal, RingDimensionSearchDomain, + PlannedSuffix, PlannedSuffixFold, PlannedSuffixTerminal, }; /// Helpers available only to synthetic schedule fixtures and profile experiments. diff --git a/crates/akita-planner/src/schedule_params.rs b/crates/akita-planner/src/schedule_params.rs index b54673380..e4e28b614 100644 --- a/crates/akita-planner/src/schedule_params.rs +++ b/crates/akita-planner/src/schedule_params.rs @@ -1,17 +1,18 @@ -//! 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 finds the global optimum under the catalog-bound +//! selection policy: proof size for uniform schedules, best preprocessing/proof +//! geometry per A path followed by per-level A rank and dimension for adaptive +//! schedules, or first direct setup footprint then proof size for recursive +//! grouped scheduling. //! //! Public entry: [`find_schedule`]. The search is `Cfg`-free: every //! per-preset input is carried by the plain-value [`PlannerPolicy`] plus //! the `ring_challenge_config` / `fold_challenge_shape_at_level` closures, //! exactly the shape generated catalog emission consumes. This keeps the DP a -//! pure function of `(policy, key, dimension domain)` for offline table generation. +//! pure function of `(policy, key)` for offline table generation; the policy +//! owns its uniform or adaptive dimension mode. use akita_challenges::{SparseChallengeConfig, TensorChallengeShape}; use akita_field::AkitaError; -#[cfg(test)] -use akita_types::extension_opening_reduction_level_bytes; use akita_types::sis::{ decomposed_s_block_ring_count, decomposed_t_ring_count, decomposed_w_ring_count, num_digits_inner, num_digits_open, num_digits_setup_prefix_commit, @@ -40,19 +41,17 @@ pub(crate) mod test_support; #[cfg(all(test, feature = "catalog-gen"))] mod unpruned_search; +pub(crate) use akita_schedules::planner_support::validate_policy; pub use candidate::suffix_opening_layout; pub(crate) use candidate::{ derive_candidate_level_params, derive_candidate_level_params_all_splits, - planned_next_witness_len, scalar_root_fold_level_params_candidate, + planned_next_witness_len, scalar_root_fold_level_params_candidate, RingDimensionCandidate, }; pub(crate) use setup_score::{ level_setup_field_elements, terminal_setup_field_elements, MixedScore, }; pub(crate) use suffix_dp::{derive_optimal_suffix_schedule, ScheduleMemo, SuffixCtx, SuffixState}; -const MIXED_SEARCH_FOLD_LEVELS: usize = 2; -const MIXED_SEARCH_SUFFIX_RING_DIMENSION: usize = 64; - #[derive(Clone, Debug)] pub(crate) struct CandidateFoldStep { pub(crate) params: CommittedGroupParams, @@ -72,96 +71,6 @@ pub(crate) struct CandidateTerminalResponse { pub(crate) estimated_payload_bytes: usize, } -/// Explicit A/B/D dimensions admitted by mixed-D planner search. -/// -/// `PlannerPolicy::ring_dimension` remains the setup generation dimension and -/// the implicit singleton domain used by [`find_schedule`]. This separate -/// offline-only value makes mixed-D search opt-in without changing runtime -/// policy or existing catalog identity. -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct RingDimensionSearchDomain { - setup_generation_dimension: usize, - candidates: Vec, -} - -impl RingDimensionSearchDomain { - /// Construct and canonicalize a non-empty dimension domain. - /// - /// Every tuple must satisfy the A-carrier invariant, and every role - /// dimension must divide `setup_generation_dimension`. - pub fn new( - setup_generation_dimension: usize, - candidates: impl IntoIterator, - ) -> Result { - if setup_generation_dimension == 0 || !setup_generation_dimension.is_power_of_two() { - return Err(AkitaError::InvalidSetup( - "setup generation dimension must be a nonzero power of two".into(), - )); - } - let mut candidates = candidates.into_iter().collect::>(); - candidates.sort_by_key(|dims| (dims.d_a(), dims.d_b(), dims.d_d())); - candidates.dedup(); - if candidates.is_empty() { - return Err(AkitaError::InvalidSetup( - "ring-dimension search domain must be nonempty".into(), - )); - } - for dims in &candidates { - dims.validate_role_projection()?; - for d in [dims.d_a(), dims.d_b(), dims.d_d()] { - if !setup_generation_dimension.is_multiple_of(d) { - return Err(AkitaError::InvalidSetup(format!( - "candidate dimension D{d} does not divide setup generation dimension \ - D{setup_generation_dimension}" - ))); - } - } - } - Ok(Self { - setup_generation_dimension, - candidates, - }) - } - - /// Construct the explicit singleton domain used by a uniform policy. - pub fn uniform(setup_generation_dimension: usize) -> Result { - Self::new( - setup_generation_dimension, - [CommitmentRingDims::uniform(setup_generation_dimension)], - ) - } - - /// Canonically ordered admitted A/B/D tuples. - pub fn candidates(&self) -> &[CommitmentRingDims] { - &self.candidates - } - - /// Setup generation dimension against which this domain was validated. - pub fn setup_generation_dimension(&self) -> usize { - self.setup_generation_dimension - } - - fn validate_for_policy(&self, policy: &PlannerPolicy) -> Result<(), AkitaError> { - if self.setup_generation_dimension != policy.ring_dimension { - return Err(AkitaError::InvalidSetup(format!( - "ring-dimension domain uses setup generation D{}, but policy uses D{}", - self.setup_generation_dimension, policy.ring_dimension - ))); - } - if self.candidates.as_slice() != policy.ring_dimension_candidates { - return Err(AkitaError::InvalidSetup( - "ring-dimension search domain disagrees with the catalog-bound policy domain" - .to_string(), - )); - } - Ok(()) - } - - fn is_uniform_policy_domain(&self, policy: &PlannerPolicy) -> bool { - self.candidates.as_slice() == [CommitmentRingDims::uniform(policy.ring_dimension)] - } -} - #[derive(Clone, Debug)] pub(crate) struct ScheduleCandidate { pub(crate) first_direct_setup_field_len: Option, @@ -179,6 +88,30 @@ impl ScheduleCandidate { pub(crate) fn first_direct_setup_field_len_or_max(&self) -> usize { self.first_direct_setup_field_len.unwrap_or(usize::MAX) } + + pub(crate) fn adaptive_a_rank_dimension_key( + &self, + num_search_levels: usize, + ) -> Vec<(usize, usize)> { + self.folds + .iter() + .take(num_search_levels) + .map(|fold| { + ( + fold.params.inner_commit_matrix.output_rank(), + fold.params.role_dims().d_a(), + ) + }) + .collect() + } + + pub(crate) fn adaptive_a_dimension_key(&self, num_search_levels: usize) -> Vec { + self.folds + .iter() + .take(num_search_levels) + .map(|fold| fold.params.role_dims().d_a()) + .collect() + } } /// Exact Stage-3 payload induced when `successor` consumes the setup prefix @@ -335,6 +268,53 @@ fn candidate_schedule_descriptor_bytes( .canonical_descriptor_bytes()) } +/// Select one setup/proof-optimal representative per exact A-dimension path, +/// then choose the path lexicographically by `(A rank, A dimension)` at each +/// searched level. This ordering prevents a worse block geometry from winning +/// merely because it happens to lower a matrix rank. +pub(crate) fn select_adaptive_candidate( + candidates: Vec, + num_search_levels: usize, + setup_generation_dimension: usize, +) -> Result, AkitaError> { + let mut per_path = candidates + .into_iter() + .map(|candidate| { + let descriptor = + candidate_schedule_descriptor_bytes(&candidate, setup_generation_dimension)?; + Ok(( + candidate.adaptive_a_dimension_key(num_search_levels), + MixedScore { + setup_field_elements: candidate.setup_field_elements, + proof_bytes: candidate.total_bytes, + }, + descriptor, + candidate, + )) + }) + .collect::, AkitaError>>()?; + per_path + .sort_by(|left, right| (&left.0, &left.1, &left.2).cmp(&(&right.0, &right.1, &right.2))); + per_path.dedup_by(|left, right| left.0 == right.0); + + let mut winners = per_path + .into_iter() + .map(|(_, score, descriptor, candidate)| { + ( + candidate.adaptive_a_rank_dimension_key(num_search_levels), + score, + descriptor, + candidate, + ) + }) + .collect::>(); + winners.sort_by(|left, right| (&left.0, &left.1, &left.2).cmp(&(&right.0, &right.1, &right.2))); + Ok(winners + .into_iter() + .next() + .map(|(_, _, _, candidate)| candidate)) +} + fn witness_partition(num_chunks: usize) -> WitnessPartition { if num_chunks == 1 { WitnessPartition::Single @@ -343,51 +323,6 @@ fn witness_partition(num_chunks: usize) -> WitnessPartition { } } -/// 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::MinFirstDirectSetupThenPayloadWithinSupportedEnvelope - } else if policy.ring_dimension_candidates.len() > 1 { - crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload - } else { - 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.max_setup_envelope_field_elements == 0 { - return Err(AkitaError::InvalidSetup( - "maximum setup envelope must be positive".to_string(), - )); - } - 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; @@ -503,12 +438,34 @@ pub fn derive_standalone_precommit_profile( let (min_log_basis, max_log_basis) = direct_policy.log_basis_search_range_at_level(0); let mut best: Option<(usize, CommittedGroupParams)> = None; + let dimensions = match direct_policy.ring_dimension_schedule_mode { + crate::RingDimensionScheduleMode::UniformDimension { ring_dimension } => { + vec![RingDimensionCandidate::Fixed(CommitmentRingDims::uniform( + ring_dimension, + ))] + } + crate::RingDimensionScheduleMode::AdaptiveDimension { + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + .. + } => potential_a_dimensions + .iter() + .copied() + .map(|inner| RingDimensionCandidate::Adaptive { + inner, + outer_dimensions: potential_b_dimensions, + opening_dimensions: potential_d_dimensions, + ceiling: CommitmentRingDims::uniform(direct_policy.ring_dimension), + }) + .collect(), + }; 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 { + for dimensions in dimensions.iter().copied() { + let Ok(ring_challenge_cfg) = ring_challenge_config(dimensions.inner()) else { continue; }; - let alpha = (dimensions.d_a() as u32).trailing_zeros() as usize; + let alpha = (dimensions.inner() as u32).trailing_zeros() as usize; let reduced_vars = key.num_vars().saturating_sub(alpha); if reduced_vars == 0 { continue; @@ -557,14 +514,10 @@ pub fn derive_standalone_precommit_profile( // memo state without changing emitted tables. pub(crate) const MAX_RECURSION_DEPTH: usize = 12; -/// Find the optimal schedule for a root schedule lookup key and dimension domain. -/// -/// A singleton domain matching the setup generation dimension preserves the -/// uniform proof-payload objective. An explicit mixed domain selects exact -/// physical setup fields first and exact proof payload second. +/// Find the optimal schedule for a root schedule lookup key. /// /// The result is a pure, -/// deterministic function of `(policy, key, dimensions)` (plus the `ring_challenge_config` / +/// deterministic function of `(policy, key)` (plus the `ring_challenge_config` / /// `fold_challenge_shape_at_level` closures, which presets derive from the same hooks the /// generated tables were emitted from), so the prover and verifier /// regenerate identical schedules on a table miss. @@ -578,67 +531,39 @@ pub fn find_schedule( key: PolynomialGroupLayout, policy: &PlannerPolicy, honest_fold_policy: HonestFoldPolicySpec, - dimensions: &RingDimensionSearchDomain, ring_challenge_config: impl Fn(usize) -> Result, fold_challenge_shape_at_level: impl Fn(AkitaScheduleInputs) -> TensorChallengeShape, ) -> Result { key.validate()?; validate_policy(policy)?; - dimensions.validate_for_policy(policy)?; - if dimensions.is_uniform_policy_domain(policy) { - return find_schedule_inner( + match policy.ring_dimension_schedule_mode { + crate::RingDimensionScheduleMode::UniformDimension { .. } => find_schedule_inner( key, policy, honest_fold_policy, ring_challenge_config, fold_challenge_shape_at_level, - ); - } - if policy.recursive_setup_planning { - return Err(AkitaError::InvalidSetup( - "mixed-D search does not yet support recursive setup planning".into(), - )); - } - if policy.witness_chunk.uses_multi_chunk() { - return Err(AkitaError::InvalidSetup( - "mixed-D search does not yet support direct multi-chunk planning".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}" - ))); + ), + crate::RingDimensionScheduleMode::AdaptiveDimension { .. } => { + if policy.recursive_setup_planning { + return Err(AkitaError::InvalidSetup( + "adaptive dimension search does not support recursive setup planning".into(), + )); + } + if policy.witness_chunk.uses_multi_chunk() { + return Err(AkitaError::InvalidSetup( + "adaptive dimension search does not support direct multi-chunk planning".into(), + )); + } + mixed_search::find_schedule( + key, + policy, + honest_fold_policy, + ring_challenge_config, + fold_challenge_shape_at_level, + ) + } } - mixed_search::find_schedule( - key, - policy, - honest_fold_policy, - dimensions, - ring_challenge_config, - fold_challenge_shape_at_level, - ) -} - -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() } /// One recursive fold of an independently planned suffix @@ -704,6 +629,14 @@ pub fn plan_optimal_suffix( start_lb: u32, ) -> Result { validate_policy(policy)?; + if matches!( + policy.ring_dimension_schedule_mode, + crate::RingDimensionScheduleMode::AdaptiveDimension { .. } + ) { + return Err(AkitaError::InvalidSetup( + "plan_optimal_suffix requires a uniform dimension policy".to_string(), + )); + } if policy.recursive_setup_planning { return Err(AkitaError::InvalidSetup( "recursive setup planning is not supported by plan_optimal_suffix".to_string(), @@ -826,7 +759,7 @@ fn find_schedule_inner( let Some(candidate_params) = scalar_root_fold_level_params_candidate( policy, &ring_challenge_cfg, - candidate_dimensions, + RingDimensionCandidate::Fixed(candidate_dimensions), key.num_vars(), key.num_polynomials(), candidate_log_basis, diff --git a/crates/akita-planner/src/schedule_params/candidate.rs b/crates/akita-planner/src/schedule_params/candidate.rs index c0803ea27..6e06f6ae4 100644 --- a/crates/akita-planner/src/schedule_params/candidate.rs +++ b/crates/akita-planner/src/schedule_params/candidate.rs @@ -1,11 +1,13 @@ use super::*; -use akita_schedules::planner_support::{projected_collision_role_price, sis_key_at_dimension}; +use akita_schedules::planner_support::sis_key_at_dimension; mod recursive; mod setup_prefix; -pub(crate) use akita_schedules::planner_support::scalar_root_fold_level_params_candidate; +pub(crate) use akita_schedules::planner_support::{ + scalar_root_fold_level_params_candidate, RingDimensionCandidate, +}; pub(crate) use recursive::{ derive_candidate_level_params, derive_candidate_level_params_all_splits, }; diff --git a/crates/akita-planner/src/schedule_params/candidate/recursive.rs b/crates/akita-planner/src/schedule_params/candidate/recursive.rs index 05ec9d243..e609910e4 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, @@ -44,18 +44,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, @@ -70,7 +71,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, fold_challenge_shape, @@ -80,12 +81,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); @@ -98,11 +94,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 { @@ -116,11 +110,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 { @@ -278,7 +270,7 @@ 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, @@ -286,7 +278,7 @@ fn prepare_recursive_level_search( requested_fold_shape: TensorChallengeShape, ) -> Result, AkitaError> { let num_chunks = policy.chunks_at_level(fold_level); - dimensions.validate_role_projection()?; + let d_a = dimensions.inner(); if current_witness_len == 0 { return Ok(None); } @@ -294,7 +286,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()))? @@ -310,7 +302,10 @@ fn prepare_recursive_level_search( let setup_prefix = match incoming_setup_prefix { Some(natural_len) => { - if dimensions != CommitmentRingDims::uniform(akita_types::SETUP_OFFLOAD_D_SETUP) { + let fixed_setup_dimensions = + CommitmentRingDims::uniform(akita_types::SETUP_OFFLOAD_D_SETUP); + if !matches!(dimensions, RingDimensionCandidate::Fixed(value) if value == fixed_setup_dimensions) + { return Err(AkitaError::InvalidSetup( "recursive setup planning requires uniform D64".to_string(), )); @@ -324,13 +319,13 @@ fn prepare_recursive_level_search( log_basis, n_prefix, num_chunks, - dimensions.d_b(), + fixed_setup_dimensions.d_b(), )? else { return Ok(None); }; Some(akita_types::setup_prefix_slot_id( - dimensions.d_a(), + fixed_setup_dimensions.d_a(), natural_len, group, )) @@ -349,7 +344,7 @@ fn prepare_recursive_level_search( fn recursive_level_candidate_for_split( policy: &PlannerPolicy, ring_challenge_cfg: &akita_challenges::SparseChallengeConfig, - dimensions: CommitmentRingDims, + dimensions: RingDimensionCandidate<'_>, search: &RecursiveLevelSearch, log_basis: u32, fold_level: usize, @@ -406,7 +401,7 @@ fn recursive_level_candidate_for_split( pub(crate) fn derive_candidate_level_params( policy: &PlannerPolicy, ring_challenge_cfg: &akita_challenges::SparseChallengeConfig, - dimensions: CommitmentRingDims, + dimensions: RingDimensionCandidate<'_>, current_witness_len: usize, log_basis: u32, fold_level: usize, @@ -459,7 +454,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, @@ -509,7 +504,7 @@ pub(crate) fn derive_candidate_level_params( pub(crate) fn derive_candidate_level_params_all_splits( policy: &PlannerPolicy, 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/mixed_search.rs b/crates/akita-planner/src/schedule_params/mixed_search.rs index d622624ef..95cb046be 100644 --- a/crates/akita-planner/src/schedule_params/mixed_search.rs +++ b/crates/akita-planner/src/schedule_params/mixed_search.rs @@ -49,7 +49,11 @@ fn insert_supported( #[allow(clippy::too_many_arguments)] fn suffix_frontier( policy: &PlannerPolicy, - dimensions: &RingDimensionSearchDomain, + num_search_levels: usize, + uniform_suffix_dimension: usize, + potential_a_dimensions: &[usize], + potential_b_dimensions: &[usize], + potential_d_dimensions: &[usize], ring_challenge_config: &dyn Fn(usize) -> Result, fold_shape: &dyn Fn(AkitaScheduleInputs) -> TensorChallengeShape, key: PolynomialGroupLayout, @@ -85,34 +89,44 @@ fn suffix_frontier( 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 dimension_candidates = if level < num_search_levels { + potential_a_dimensions + .iter() + .copied() + .filter(|&inner| inner <= dimension_ceiling.d_a()) + .map(|inner| RingDimensionCandidate::Adaptive { + inner, + outer_dimensions: potential_b_dimensions, + opening_dimensions: potential_d_dimensions, + ceiling: dimension_ceiling, + }) + .collect::>() + } else { + vec![RingDimensionCandidate::Fixed(CommitmentRingDims::uniform( + uniform_suffix_dimension, + ))] + }; + for candidate_dimensions in dimension_candidates { + let d_a = candidate_dimensions.inner(); 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(), + d_a, )? else { continue; }; - let Ok(ring_challenge) = ring_challenge_config(candidate_dimensions.d_a()) else { + let Ok(ring_challenge) = ring_challenge_config(d_a) else { continue; }; - let candidates = if level < MIXED_SEARCH_FOLD_LEVELS { + let candidates = if level < num_search_levels { derive_candidate_level_params_all_splits( policy, &ring_challenge, - *candidate_dimensions, + candidate_dimensions, input_witness_len, log_basis, level, @@ -123,7 +137,7 @@ fn suffix_frontier( derive_candidate_level_params( policy, &ring_challenge, - *candidate_dimensions, + candidate_dimensions, input_witness_len, log_basis, level, @@ -135,7 +149,7 @@ fn suffix_frontier( }; for (params, output_witness_len) in candidates { - if level >= MIXED_SEARCH_FOLD_LEVELS { + if level >= num_search_levels { if let Some((mut terminal, terminal_bytes)) = suffix_dp::try_terminal_direct_suffix_cost( input_witness_len, @@ -181,14 +195,18 @@ fn suffix_frontier( } } - let child_ceiling = if level + 1 >= MIXED_SEARCH_FOLD_LEVELS { - CommitmentRingDims::uniform(MIXED_SEARCH_SUFFIX_RING_DIMENSION) + let child_ceiling = if level + 1 >= num_search_levels { + CommitmentRingDims::uniform(uniform_suffix_dimension) } else { params.role_dims() }; for child in suffix_frontier( policy, - dimensions, + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, ring_challenge_config, fold_shape, key, @@ -255,10 +273,21 @@ pub(super) fn find_schedule( key: PolynomialGroupLayout, policy: &PlannerPolicy, honest_fold_policy: HonestFoldPolicySpec, - dimensions: &RingDimensionSearchDomain, ring_challenge_config: impl Fn(usize) -> Result, fold_shape: impl Fn(AkitaScheduleInputs) -> TensorChallengeShape, ) -> Result { + let crate::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + } = policy.ring_dimension_schedule_mode + else { + return Err(AkitaError::InvalidSetup( + "adaptive planner requires AdaptiveDimension policy".to_string(), + )); + }; let field_bits = policy.decomposition.field_bits(); let input_witness_len = 1usize .checked_shl(key.num_vars() as u32) @@ -274,22 +303,28 @@ pub(super) fn find_schedule( let mut complete = Vec::new(); 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; + for &root_d_a in potential_a_dimensions { + let root_dimensions = RingDimensionCandidate::Adaptive { + inner: root_d_a, + outer_dimensions: potential_b_dimensions, + opening_dimensions: potential_d_dimensions, + ceiling: CommitmentRingDims::uniform(policy.ring_dimension), + }; + let alpha = root_d_a.trailing_zeros() as usize; let reduced_vars = key.num_vars().saturating_sub(alpha); if reduced_vars == 0 { continue; } let min_block_bits = if reduced_vars >= 3 { 1 } else { 0 }; let max_block_bits = (reduced_vars - 1).min(usize::BITS as usize - 1); - let Ok(ring_challenge) = ring_challenge_config(root_dimensions.d_a()) else { + let Ok(ring_challenge) = ring_challenge_config(root_d_a) else { continue; }; for block_bits in (min_block_bits..=max_block_bits).rev() { let Some(root_params) = scalar_root_fold_level_params_candidate( policy, &ring_challenge, - *root_dimensions, + root_dimensions, key.num_vars(), key.num_polynomials(), log_basis, @@ -323,21 +358,29 @@ pub(super) fn find_schedule( 0, key, input_witness_len, - root_dimensions.d_a(), + root_d_a, )? else { continue; }; for suffix in suffix_frontier( policy, - dimensions, + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, &ring_challenge_config, &fold_shape, key, 1, output_witness_len, log_basis, - *root_dimensions, + if num_search_levels <= 1 { + CommitmentRingDims::uniform(uniform_suffix_dimension) + } else { + root_params.role_dims() + }, &mut memo, )? { let child_is_terminal = suffix.folds.is_empty(); @@ -384,23 +427,9 @@ pub(super) fn find_schedule( } } - let mut scored = complete - .into_iter() - .map(|candidate| { - let descriptor = - candidate_schedule_descriptor_bytes(&candidate, policy.ring_dimension)?; - Ok(( - MixedScore { - setup_field_elements: candidate.setup_field_elements, - proof_bytes: candidate.total_bytes, - }, - descriptor, - candidate, - )) - }) - .collect::, AkitaError>>()?; - scored.sort_by(|left, right| (&left.0, &left.1).cmp(&(&right.0, &right.1))); - let Some((_, _, selected)) = scored.into_iter().next() else { + let Some(selected) = + select_adaptive_candidate(complete, num_search_levels, policy.ring_dimension)? + else { return Err(AkitaError::UnsupportedSchedule(format!( "no mixed-D schedule with at least two folds for num_vars={}, num_polynomials={}", key.num_vars(), diff --git a/crates/akita-planner/src/schedule_params/suffix_dp.rs b/crates/akita-planner/src/schedule_params/suffix_dp.rs index 4c66f8f73..087bfcb62 100644 --- a/crates/akita-planner/src/schedule_params/suffix_dp.rs +++ b/crates/akita-planner/src/schedule_params/suffix_dp.rs @@ -15,7 +15,7 @@ use crate::{group_batch::multi_group_root_level_candidates_for_basis, PlannerPol 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, + CandidateTerminalResponse, RingDimensionCandidate, ScheduleCandidate, MAX_RECURSION_DEPTH, }; /// Result of the suffix DP at one state. Both shape options are reported @@ -569,7 +569,7 @@ pub(crate) fn derive_optimal_suffix_schedule( let Some(candidate) = derive_candidate_level_params( policy, &ring_challenge_cfg, - dimensions, + RingDimensionCandidate::Fixed(dimensions), current_witness_len, lb, level, diff --git a/crates/akita-planner/src/schedule_params/tests.rs b/crates/akita-planner/src/schedule_params/tests.rs index e7a15abe1..5d85d4278 100644 --- a/crates/akita-planner/src/schedule_params/tests.rs +++ b/crates/akita-planner/src/schedule_params/tests.rs @@ -1,23 +1,9 @@ use super::*; -#[cfg(feature = "catalog-gen")] -fn policy_for_domain( - mut policy: PlannerPolicy, - domain: &RingDimensionSearchDomain, -) -> PlannerPolicy { - policy.ring_dimension_candidates = Box::leak(domain.candidates().to_vec().into_boxed_slice()); - policy.selection_policy = if domain.candidates().len() > 1 { - crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload - } else { - crate::SelectionPolicyId::MinEstimatedProofPayload - }; - policy -} - #[test] fn tensor_low_length_is_selected_independently() { assert_eq!( - optimize_fold_challenge_shape(TensorChallengeShape::Tensor { fold_low_len: 1 }, 13,) + optimize_fold_challenge_shape(TensorChallengeShape::Tensor { fold_low_len: 1 }, 13) .unwrap(), TensorChallengeShape::Tensor { fold_low_len: 4 }, ); @@ -36,658 +22,285 @@ fn balanced_chunk_geometry_prices_exact_work_and_residual_imbalance() { ); } +#[cfg(feature = "catalog-gen")] #[test] -fn ring_dimension_domain_is_canonical_and_rejects_invalid_carriers() { - let domain = RingDimensionSearchDomain::new( - 256, - [ - CommitmentRingDims { - inner: 128, - outer: 64, - opening: 64, - }, - CommitmentRingDims::uniform(64), - CommitmentRingDims { - inner: 128, - outer: 64, - opening: 64, - }, - ], - ) - .unwrap(); - assert_eq!( - domain.candidates(), - &[ - CommitmentRingDims::uniform(64), - CommitmentRingDims { - inner: 128, - outer: 64, - opening: 64 - }, - ] - ); - assert!(RingDimensionSearchDomain::new( - 256, - [CommitmentRingDims { - inner: 64, - outer: 128, - opening: 64 - }] - ) - .is_err()); - assert!(RingDimensionSearchDomain::new(128, [CommitmentRingDims::uniform(256)]).is_err()); +fn adaptive_policy_rejects_role_dimensions_below_suffix() { + use akita_config::{policy_of, proof_optimized::fp128::MixedDimFp128OneHot}; + + static INVALID_B_DIMENSIONS: &[usize] = &[32, 64, 128]; + let mut policy = policy_of::(); + let crate::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_d_dimensions, + .. + } = policy.ring_dimension_schedule_mode + else { + panic!("test preset must be adaptive"); + }; + policy.ring_dimension_schedule_mode = crate::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions: INVALID_B_DIMENSIONS, + potential_d_dimensions, + }; + assert!(validate_policy(&policy).is_err()); } #[cfg(feature = "catalog-gen")] #[test] -fn mixed_domain_search_beats_or_ties_uniform_d64() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; +fn adaptive_schedule_obeys_search_window_and_uniform_suffix() { + use akita_config::{policy_of, proof_optimized::fp128::MixedDimFp128OneHot, CommitmentConfig}; - let base_policy = policy_of::(); - let dimensions = [ - CommitmentRingDims::uniform(64), - CommitmentRingDims { - inner: 128, - outer: 64, - opening: 64, - }, - ]; - let domain = RingDimensionSearchDomain::new(base_policy.ring_dimension, dimensions).unwrap(); - let policy = policy_for_domain(base_policy, &domain); - let key = PolynomialGroupLayout::singleton(16); - let selected = find_schedule( - key, + let policy = policy_of::(); + let planned = find_schedule( + PolynomialGroupLayout::singleton(18), &policy, - D256OneHot::root_honest_fold_policy(), - &domain, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, + MixedDimFp128OneHot::root_honest_fold_policy(), + MixedDimFp128OneHot::ring_challenge_config, + MixedDimFp128OneHot::fold_challenge_shape_at_level, ) .unwrap(); - let selected_score = ( - selected.estimate.estimated_setup_envelope_ring_elements, - selected.estimate.estimated_proof_payload_bytes().unwrap(), - ); + let crate::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + } = policy.ring_dimension_schedule_mode + else { + panic!("test preset must be adaptive"); + }; - let uniform = RingDimensionSearchDomain::new(policy.ring_dimension, [dimensions[0]]).unwrap(); - let uniform_policy = policy_for_domain(policy_of::(), &uniform); - let candidate = find_schedule( - key, - &uniform_policy, - D256OneHot::root_honest_fold_policy(), - &uniform, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .unwrap(); - assert!( - selected_score - <= ( - candidate.estimate.estimated_setup_envelope_ring_elements, - candidate.estimate.estimated_proof_payload_bytes().unwrap(), - ) + let mut levels = Vec::with_capacity(planned.schedule.recursive_folds.len() + 1); + levels.push( + planned + .schedule + .root + .params + .final_group + .commitment + .role_dims(), ); - - let schedule = &selected.schedule; - assert!(domain - .candidates() - .contains(&schedule.root.params.final_group.commitment.role_dims())); - let mut previous = schedule.root.params.final_group.commitment.role_dims(); - 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 { + levels.extend( + planned + .schedule + .recursive_folds + .iter() + .map(|fold| fold.params.witness.role_dims()), + ); + for (level, dimensions) in levels.iter().copied().enumerate() { + if level < num_search_levels { + assert!(potential_a_dimensions.contains(&dimensions.d_a())); + assert!(potential_b_dimensions.contains(&dimensions.d_b())); + assert!(potential_d_dimensions.contains(&dimensions.d_d())); + } else { assert_eq!( - current, - CommitmentRingDims::uniform(MIXED_SEARCH_SUFFIX_RING_DIMENSION) + dimensions, + CommitmentRingDims::uniform(uniform_suffix_dimension) ); } - previous = current; + if let Some(previous) = level.checked_sub(1).map(|index| levels[index]) { + assert!(dimensions.d_a() <= previous.d_a()); + assert!(dimensions.d_b() <= previous.d_b()); + assert!(dimensions.d_d() <= previous.d_d()); + } } assert_eq!( - schedule.terminal.params.witness.d_a(), - MIXED_SEARCH_SUFFIX_RING_DIMENSION + planned.schedule.terminal.params.witness.d_a(), + uniform_suffix_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), +fn adaptive_role_selection_minimizes_rank_then_dimension() { + use akita_config::{policy_of, proof_optimized::fp128::MixedDimFp128OneHot, CommitmentConfig}; + + let policy = policy_of::(); + let plan = |num_vars| { + find_schedule( + PolynomialGroupLayout::singleton(num_vars), + &policy, + MixedDimFp128OneHot::root_honest_fold_policy(), + MixedDimFp128OneHot::ring_challenge_config, + MixedDimFp128OneHot::fold_challenge_shape_at_level, + ) + .unwrap() + }; + let nv18_plan = plan(18); + let nv18 = &nv18_plan.schedule.root.params.final_group.commitment; + assert_eq!( + nv18.role_dims(), CommitmentRingDims { - inner: 128, + inner: 256, outer: 64, opening: 64, - }, - ]; - let domain = RingDimensionSearchDomain::new(base_policy.ring_dimension, dimensions).unwrap(); - let policy = policy_for_domain(base_policy, &domain); - let key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::singleton(16)); - - let grouped = crate::find_group_batch_schedule( - &key, - D256OneHot::root_honest_fold_policy(), - &[], - &policy, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .unwrap(); - let direct = find_schedule( - key.final_group, - &policy, - D256OneHot::root_honest_fold_policy(), - &domain, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .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() + } ); -} - -#[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}; - - let base_policy = policy_of::(); - let d64 = CommitmentRingDims::uniform(64); - let a128 = CommitmentRingDims { - inner: 128, - outer: 64, - opening: 64, - }; - let reversed_with_duplicate = - RingDimensionSearchDomain::new(base_policy.ring_dimension, [a128, d64, a128]).unwrap(); - let canonical = - RingDimensionSearchDomain::new(base_policy.ring_dimension, [d64, a128]).unwrap(); - let policy = policy_for_domain(base_policy, &canonical); - let key = PolynomialGroupLayout::singleton(16); - - let selected = find_schedule( - key, - &policy, - D256OneHot::root_honest_fold_policy(), - &reversed_with_duplicate, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .unwrap(); - let unpruned = unpruned_search::find_schedule( - key, - &policy, - D256OneHot::root_honest_fold_policy(), - &canonical, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .unwrap(); - let repeated = find_schedule( - key, - &policy, - D256OneHot::root_honest_fold_policy(), - &canonical, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .unwrap(); + assert_eq!(nv18.outer_commit_matrix.output_rank(), 1); + assert_eq!(nv18.open_commit_matrix.output_rank(), 1); + let nv36_plan = plan(36); + let nv36 = &nv36_plan.schedule.root.params.final_group.commitment; assert_eq!( - ( - selected.estimate.estimated_setup_envelope_ring_elements, - selected.estimate.estimated_proof_payload_bytes().unwrap(), - ), - ( - unpruned.estimate.estimated_setup_envelope_ring_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() + nv36.role_dims(), + CommitmentRingDims { + inner: 256, + outer: 128, + opening: 128, + } ); -} - -#[cfg(feature = "catalog-gen")] -#[test] -fn mixed_search_parallel_generation_is_descriptor_deterministic() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; - - let handles = (0..8) - .map(|_| { - std::thread::spawn(|| { - let base_policy = policy_of::(); - let domain = RingDimensionSearchDomain::new( - base_policy.ring_dimension, - [ - CommitmentRingDims { - inner: 128, - outer: 64, - opening: 64, - }, - CommitmentRingDims::uniform(64), - ], - ) - .expect("mixed dimension domain"); - let policy = policy_for_domain(base_policy, &domain); - find_schedule( - PolynomialGroupLayout::singleton(16), - &policy, - D256OneHot::root_honest_fold_policy(), - &domain, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .expect("parallel mixed planner run") - .schedule - .canonical_descriptor_bytes() - }) - }) - .collect::>(); - let descriptors = handles - .into_iter() - .map(|handle| handle.join().expect("planner thread")) - .collect::>(); - assert!(descriptors.windows(2).all(|pair| pair[0] == pair[1])); -} - -#[cfg(feature = "catalog-gen")] -#[test] -fn mixed_root_prices_eor_at_candidate_a_dimension() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; - - 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); - let domain = RingDimensionSearchDomain::new(policy.ring_dimension, [candidate_dimensions]) - .expect("mixed dimension domain"); - policy = policy_for_domain(policy, &domain); - let key = PolynomialGroupLayout::singleton(16); - let selected = find_schedule( - key, - &policy, - D256OneHot::root_honest_fold_policy(), - &domain, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .expect("mixed planner boundary schedule"); - let schedule = &selected.schedule; - let root_params = &schedule.root.params.final_group.commitment; - assert_eq!(root_params.role_dims(), candidate_dimensions); - - let challenge_field_bits = policy.challenge_field_bits().expect("valid policy"); - let candidate_eor_bytes = extension_opening_reduction_level_bytes( - challenge_field_bits, - policy.claim_ext_degree, - 0, - key, - schedule.root.input_witness_len, - candidate_dimensions.d_a(), - ) - .expect("candidate EOR bytes"); - let setup_generation_eor_bytes = extension_opening_reduction_level_bytes( - challenge_field_bits, - policy.claim_ext_degree, - 0, - key, - schedule.root.input_witness_len, - policy.ring_dimension, - ) - .expect("setup-generation EOR bytes"); - assert_eq!(candidate_eor_bytes, 0); - assert!(setup_generation_eor_bytes > 0); - - let next_params = schedule - .recursive_folds - .first() - .map(|step| &step.params.witness); - let next_binding = if next_params.is_some() { - akita_types::NextWitnessBindingPolicy::OuterCommitment - } else { - akita_types::NextWitnessBindingPolicy::TerminalInnerState - }; - let root_without_eor = level_proof_bytes( - policy.decomposition.field_bits(), - challenge_field_bits, - root_params, - next_params, - schedule.root.output_witness_len, - Some(next_binding), - ) - .expect("root bytes without EOR"); + assert_eq!(nv36.outer_commit_matrix.output_rank(), 1); + assert_eq!(nv36.open_commit_matrix.output_rank(), 1); + let nv36_l1 = &nv36_plan.schedule.recursive_folds[0].params.witness; assert_eq!( - selected.estimate.estimated_root_direct_payload_bytes, - root_without_eor + candidate_eor_bytes, - ); -} - -#[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}; - - let base_policy = policy_of::(); - let d64 = CommitmentRingDims::uniform(64); - let unsupported_uniform_d512 = CommitmentRingDims::uniform(512); - let domain = - RingDimensionSearchDomain::new(base_policy.ring_dimension, [d64, unsupported_uniform_d512]) - .expect("mixed domain"); - let policy = policy_for_domain(base_policy, &domain); - let selected = find_schedule( - PolynomialGroupLayout::singleton(16), - &policy, - D512OneHot::root_honest_fold_policy(), - &domain, - D512OneHot::ring_challenge_config, - D512OneHot::fold_challenge_shape_at_level, - ) - .expect("the supported D64 sibling must survive"); - - assert_eq!( - selected - .schedule - .root - .params - .final_group - .commitment - .role_dims(), - d64 + nv36_l1.role_dims(), + CommitmentRingDims { + inner: 256, + outer: 64, + opening: 64, + } ); -} - -#[cfg(feature = "catalog-gen")] -#[test] -fn mixed_nv36_benchmark_policy_selects_minimum_setup_schedule() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; - - let base_policy = policy_of::(); - let d64 = CommitmentRingDims::uniform(64); - let d128_mixed = CommitmentRingDims { - inner: 128, - outer: 64, - opening: 64, - }; - let d128 = CommitmentRingDims::uniform(128); - let d256_mixed = CommitmentRingDims { - inner: 256, - outer: 128, - opening: 128, + assert_eq!(nv36_l1.inner_commit_matrix.output_rank(), 2); + assert_eq!(nv36_l1.outer_commit_matrix.output_rank(), 1); + assert_eq!(nv36_l1.open_commit_matrix.output_rank(), 1); + + let rank_at = |commitment: &CommittedGroupParams, + role: akita_types::SisMatrixRole, + candidate_dimension: usize| { + let selected_dimension = match role { + akita_types::SisMatrixRole::Outer => commitment.role_dims().d_b(), + akita_types::SisMatrixRole::Open => commitment.role_dims().d_d(), + akita_types::SisMatrixRole::Inner => unreachable!("test prices collision roles"), + }; + let selected_width = match role { + akita_types::SisMatrixRole::Outer => commitment.outer_commit_matrix.input_width(), + akita_types::SisMatrixRole::Open => commitment.open_commit_matrix.input_width(), + akita_types::SisMatrixRole::Inner => unreachable!("test prices collision roles"), + }; + let native_width = selected_width / (commitment.role_dims().d_a() / selected_dimension); + let (key, width) = akita_schedules::planner_support::projected_collision_role_price( + &policy, + role, + commitment.role_dims().d_a(), + candidate_dimension, + native_width, + commitment.log_basis_outer, + ) + .unwrap(); + akita_types::sis::min_secure_rank(key, u64::try_from(width).unwrap()).unwrap() }; - let domain = RingDimensionSearchDomain::new( - base_policy.ring_dimension, - [d64, d128_mixed, d128, d256_mixed], - ) - .expect("benchmark dimension domain"); - let policy = policy_for_domain(base_policy, &domain); - let selected = find_schedule( - PolynomialGroupLayout::singleton(36), - &policy, - D256OneHot::root_honest_fold_policy(), - &domain, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .expect("nv36 mixed planner"); - let rank_one_capped_domain = - RingDimensionSearchDomain::new(policy.ring_dimension, [d64, d128_mixed, d128]) - .expect("rank-one-capped comparison domain"); - let mut comparison_policy = - policy_for_domain(policy_of::(), &rank_one_capped_domain); - comparison_policy.max_setup_envelope_field_elements = usize::MAX; - let rank_one_capped = find_schedule( - PolynomialGroupLayout::singleton(36), - &comparison_policy, - D256OneHot::root_honest_fold_policy(), - &rank_one_capped_domain, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .expect("rank-one-capped nv36 planner"); - let selected_root = &selected.schedule.root.params.final_group.commitment; - let rank_one_capped_root = &rank_one_capped.schedule.root.params.final_group.commitment; + assert_eq!(rank_at(nv18, akita_types::SisMatrixRole::Outer, 64), 1); + assert_eq!(rank_at(nv18, akita_types::SisMatrixRole::Open, 64), 1); + assert_eq!(rank_at(nv36, akita_types::SisMatrixRole::Outer, 64), 2); + assert_eq!(rank_at(nv36, akita_types::SisMatrixRole::Open, 64), 2); - assert_eq!(selected_root.role_dims(), d256_mixed); assert_eq!( - selected.schedule.recursive_folds[0] - .params - .witness - .role_dims(), - CommitmentRingDims::uniform(64) - ); - assert_eq!( - selected.estimate.estimated_setup_envelope_ring_elements, + nv36_plan.estimate.estimated_setup_envelope_ring_elements, 176_128 ); assert_eq!( - selected.estimate.estimated_proof_payload_bytes().unwrap(), - 98_728 - ); - assert_eq!(rank_one_capped_root.inner_commit_matrix.output_rank(), 3); - assert_eq!(selected_root.inner_commit_matrix.output_rank(), 1); - assert_eq!(rank_one_capped_root.outer_commit_matrix.output_rank(), 1); - assert_eq!(selected_root.outer_commit_matrix.output_rank(), 1); - assert!( - selected_root.outer_commit_matrix.input_width() - < rank_one_capped_root.outer_commit_matrix.input_width(), - "the lower D256 A rank must reduce B width despite both B matrices having rank one" - ); - assert!( - selected.estimate.estimated_setup_envelope_ring_elements - < rank_one_capped - .estimate - .estimated_setup_envelope_ring_elements, - "the rank-two D256 candidate must beat the rank-one-capped search on setup" + nv36_plan.estimate.estimated_proof_payload_bytes().unwrap(), + 99_512 ); } #[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_a_rank_fallback_accepts_rank_above_one() { + use akita_config::{policy_of, proof_optimized::fp128::MixedDimFp128OneHot, CommitmentConfig}; - let base_policy = policy_of::(); - let missing_d64 = RingDimensionSearchDomain::new( - base_policy.ring_dimension, - [CommitmentRingDims::uniform(128)], + let mut policy = policy_of::(); + policy.max_setup_envelope_field_elements = usize::MAX; + let planned = find_schedule( + PolynomialGroupLayout::singleton(40), + &policy, + MixedDimFp128OneHot::root_honest_fold_policy(), + MixedDimFp128OneHot::ring_challenge_config, + MixedDimFp128OneHot::fold_challenge_shape_at_level, ) .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(), - &missing_d64, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .unwrap_err(); - assert!(error - .to_string() - .contains("requires the D64 uniform candidate")); + let root = &planned.schedule.root.params.final_group.commitment; + let l1 = &planned.schedule.recursive_folds[0].params.witness; - let below_d64 = RingDimensionSearchDomain::new( - base_policy.ring_dimension, - [ - CommitmentRingDims::uniform(64), - CommitmentRingDims { - inner: 128, - outer: 32, - opening: 64, - }, - ], - ) - .unwrap(); - let below_policy = policy_for_domain(base_policy, &below_d64); - let error = find_schedule( - PolynomialGroupLayout::singleton(16), - &below_policy, - D256OneHot::root_honest_fold_policy(), - &below_d64, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .unwrap_err(); - assert!(error.to_string().contains("component-wise at least D64")); + assert_eq!(root.role_dims().d_a(), 256); + assert_eq!(root.inner_commit_matrix.output_rank(), 2); + assert_eq!(l1.role_dims().d_a(), 256); + assert_eq!(l1.inner_commit_matrix.output_rank(), 2); + assert_eq!( + akita_types::setup_matrix_field_elements_for_schedule(&planned.schedule).unwrap(), + 268_435_456 + ); } #[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_rejects_multi_chunk_policy() { + use akita_config::{policy_of, proof_optimized::fp128::MixedDimFp128OneHot, CommitmentConfig}; - let mut policy = policy_of::(); + let mut policy = policy_of::(); policy.witness_chunk = akita_types::ChunkedWitnessCfg::d64_production(); - let domain = - RingDimensionSearchDomain::new(policy.ring_dimension, [CommitmentRingDims::uniform(64)]) - .unwrap(); - policy = policy_for_domain(policy, &domain); let error = find_schedule( - PolynomialGroupLayout::singleton(16), + PolynomialGroupLayout::singleton(18), &policy, - D256OneHot::root_honest_fold_policy(), - &domain, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, + MixedDimFp128OneHot::root_honest_fold_policy(), + MixedDimFp128OneHot::ring_challenge_config, + MixedDimFp128OneHot::fold_challenge_shape_at_level, ) .unwrap_err(); assert!(error .to_string() - .contains("does not yet support direct multi-chunk planning")); + .contains("does not support direct multi-chunk planning")); } #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_validates_key_and_policy_at_entry() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; - - let base_policy = policy_of::(); - let domain = RingDimensionSearchDomain::new( - base_policy.ring_dimension, - [ - CommitmentRingDims::uniform(64), - CommitmentRingDims::uniform(base_policy.ring_dimension), - ], - ) - .unwrap(); - let policy = policy_for_domain(base_policy, &domain); +fn adaptive_search_validates_key_policy_and_physical_setup_budget() { + use akita_config::{policy_of, proof_optimized::fp128::MixedDimFp128OneHot, CommitmentConfig}; + let mut policy = policy_of::(); let error = find_schedule( - PolynomialGroupLayout::new(16, 0), + PolynomialGroupLayout::new(18, 0), &policy, - D256OneHot::root_honest_fold_policy(), - &domain, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, + MixedDimFp128OneHot::root_honest_fold_policy(), + MixedDimFp128OneHot::ring_challenge_config, + MixedDimFp128OneHot::fold_challenge_shape_at_level, ) .unwrap_err(); assert!(error .to_string() .contains("opening group layouts must be nonempty")); - let mut invalid_policy = policy; - invalid_policy.max_setup_envelope_field_elements = 0; - let error = find_schedule( - PolynomialGroupLayout::singleton(16), - &invalid_policy, - D256OneHot::root_honest_fold_policy(), - &domain, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, + policy.max_setup_envelope_field_elements = 1; + assert!(find_schedule( + PolynomialGroupLayout::singleton(18), + &policy, + MixedDimFp128OneHot::root_honest_fold_policy(), + MixedDimFp128OneHot::ring_challenge_config, + MixedDimFp128OneHot::fold_challenge_shape_at_level, ) - .unwrap_err(); - assert!(error - .to_string() - .contains("maximum setup envelope must be positive")); -} - -#[cfg(feature = "catalog-gen")] -#[test] -fn dimension_domain_is_bound_to_setup_generation_dimension() { - use akita_config::{policy_of, proof_optimized::fp128::D128OneHot, CommitmentConfig}; + .is_err()); - let policy = policy_of::(); - let domain = RingDimensionSearchDomain::uniform(256).unwrap(); + policy.max_setup_envelope_field_elements = 0; let error = find_schedule( - PolynomialGroupLayout::singleton(16), + PolynomialGroupLayout::singleton(18), &policy, - D128OneHot::root_honest_fold_policy(), - &domain, - D128OneHot::ring_challenge_config, - D128OneHot::fold_challenge_shape_at_level, + MixedDimFp128OneHot::root_honest_fold_policy(), + MixedDimFp128OneHot::ring_challenge_config, + MixedDimFp128OneHot::fold_challenge_shape_at_level, ) .unwrap_err(); assert!(error .to_string() - .contains("domain uses setup generation D256, but policy uses D128")); -} - -#[cfg(feature = "catalog-gen")] -#[test] -fn mixed_search_applies_setup_budget_in_physical_fields() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; - - let mut policy = policy_of::(); - let domain = RingDimensionSearchDomain::new( - policy.ring_dimension, - [ - CommitmentRingDims::uniform(64), - CommitmentRingDims { - inner: 128, - outer: 64, - opening: 64, - }, - ], - ) - .unwrap(); - policy = policy_for_domain(policy, &domain); - let selected = find_schedule( - PolynomialGroupLayout::singleton(16), - &policy, - D256OneHot::root_honest_fold_policy(), - &domain, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .unwrap(); - let exact_fields = - akita_types::setup_matrix_field_elements_for_schedule(&selected.schedule).unwrap(); - policy.max_setup_envelope_field_elements = exact_fields - 1; - - let error = find_schedule( - PolynomialGroupLayout::singleton(16), - &policy, - D256OneHot::root_honest_fold_policy(), - &domain, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .unwrap_err(); - assert!(error.to_string().contains("no mixed-D schedule")); + .contains("maximum setup envelope must be positive")); } #[cfg(feature = "catalog-gen")] #[test] -fn preserved_recursive_proof_size_is_documented() { +fn preserved_recursive_proof_size_is_unchanged() { use akita_config::{ policy_of, proof_optimized::fp128::D64OneHot, CommitmentConfig, RecursiveCommitmentConfig, }; @@ -695,14 +308,10 @@ fn preserved_recursive_proof_size_is_documented() { type Recursive = RecursiveCommitmentConfig; let precommit_layout = PolynomialGroupLayout::singleton(16); - let precommit_policy = policy_of::(); - let precommit_domain = - RingDimensionSearchDomain::uniform(precommit_policy.ring_dimension).unwrap(); let precommit = find_schedule( precommit_layout, - &precommit_policy, + &policy_of::(), D64OneHot::root_honest_fold_policy(), - &precommit_domain, D64OneHot::ring_challenge_config, D64OneHot::fold_challenge_shape_at_level, ) @@ -727,9 +336,59 @@ fn preserved_recursive_proof_size_is_documented() { Recursive::fold_challenge_shape_at_level, ) .unwrap(); - assert_eq!( planned.estimate.estimated_proof_payload_bytes().unwrap(), 102_732 ); } + +#[cfg(feature = "catalog-gen")] +#[test] +fn adaptive_schedule_is_descriptor_deterministic() { + use akita_config::{policy_of, proof_optimized::fp128::MixedDimFp128OneHot, CommitmentConfig}; + + let policy = policy_of::(); + let plan = || { + find_schedule( + PolynomialGroupLayout::singleton(18), + &policy, + MixedDimFp128OneHot::root_honest_fold_policy(), + MixedDimFp128OneHot::ring_challenge_config, + MixedDimFp128OneHot::fold_challenge_shape_at_level, + ) + .unwrap() + .schedule + .canonical_descriptor_bytes() + }; + assert_eq!(plan(), plan()); +} + +#[cfg(feature = "catalog-gen")] +#[test] +fn adaptive_frontier_matches_unpruned_traversal() { + use akita_config::{policy_of, proof_optimized::fp128::MixedDimFp128OneHot, CommitmentConfig}; + + let policy = policy_of::(); + let key = PolynomialGroupLayout::singleton(18); + let pruned = find_schedule( + key, + &policy, + MixedDimFp128OneHot::root_honest_fold_policy(), + MixedDimFp128OneHot::ring_challenge_config, + MixedDimFp128OneHot::fold_challenge_shape_at_level, + ) + .unwrap(); + let unpruned = unpruned_search::find_schedule( + key, + &policy, + MixedDimFp128OneHot::root_honest_fold_policy(), + MixedDimFp128OneHot::ring_challenge_config, + MixedDimFp128OneHot::fold_challenge_shape_at_level, + ) + .unwrap(); + assert_eq!( + pruned.schedule.canonical_descriptor_bytes(), + unpruned.schedule.canonical_descriptor_bytes() + ); + assert_eq!(pruned.estimate, unpruned.estimate); +} diff --git a/crates/akita-planner/src/schedule_params/unpruned_search.rs b/crates/akita-planner/src/schedule_params/unpruned_search.rs index b25dccea3..0e374e8a6 100644 --- a/crates/akita-planner/src/schedule_params/unpruned_search.rs +++ b/crates/akita-planner/src/schedule_params/unpruned_search.rs @@ -2,7 +2,11 @@ use super::*; struct UnprunedCtx<'a> { policy: &'a PlannerPolicy, - dimensions: &'a RingDimensionSearchDomain, + num_search_levels: usize, + uniform_suffix_dimension: usize, + potential_a_dimensions: &'a [usize], + potential_b_dimensions: &'a [usize], + potential_d_dimensions: &'a [usize], ring_challenge_config: &'a dyn Fn(usize) -> Result, fold_shape: &'a dyn Fn(AkitaScheduleInputs) -> TensorChallengeShape, key: PolynomialGroupLayout, @@ -22,7 +26,11 @@ fn enumerate_suffixes( ) -> Result, AkitaError> { let UnprunedCtx { policy, - dimensions, + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, ring_challenge_config, fold_shape, key, @@ -47,34 +55,44 @@ fn enumerate_suffixes( let mut schedules = 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 dimension_candidates = if level < num_search_levels { + potential_a_dimensions + .iter() + .copied() + .filter(|&inner| inner <= dimension_ceiling.d_a()) + .map(|inner| RingDimensionCandidate::Adaptive { + inner, + outer_dimensions: potential_b_dimensions, + opening_dimensions: potential_d_dimensions, + ceiling: dimension_ceiling, + }) + .collect::>() + } else { + vec![RingDimensionCandidate::Fixed(CommitmentRingDims::uniform( + uniform_suffix_dimension, + ))] + }; + for candidate_dimensions in dimension_candidates { + let d_a = candidate_dimensions.inner(); 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(), + d_a, )? else { continue; }; - let Ok(ring_challenge) = ring_challenge_config(candidate_dimensions.d_a()) else { + let Ok(ring_challenge) = ring_challenge_config(d_a) else { continue; }; - let candidates = if level < MIXED_SEARCH_FOLD_LEVELS { + let candidates = if level < num_search_levels { derive_candidate_level_params_all_splits( policy, &ring_challenge, - *candidate_dimensions, + candidate_dimensions, input_witness_len, log_basis, level, @@ -85,7 +103,7 @@ fn enumerate_suffixes( derive_candidate_level_params( policy, &ring_challenge, - *candidate_dimensions, + candidate_dimensions, input_witness_len, log_basis, level, @@ -97,7 +115,7 @@ fn enumerate_suffixes( }; for (params, output_witness_len) in candidates { - if level >= MIXED_SEARCH_FOLD_LEVELS { + if level >= num_search_levels { if let Some((mut terminal, terminal_bytes)) = suffix_dp::try_terminal_direct_suffix_cost( input_witness_len, @@ -137,8 +155,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 >= num_search_levels { + CommitmentRingDims::uniform(uniform_suffix_dimension) } else { params.role_dims() }; @@ -207,13 +225,23 @@ pub(super) fn find_schedule( key: PolynomialGroupLayout, policy: &PlannerPolicy, honest_fold_policy: HonestFoldPolicySpec, - dimensions: &RingDimensionSearchDomain, ring_challenge_config: impl Fn(usize) -> Result, fold_shape: impl Fn(AkitaScheduleInputs) -> TensorChallengeShape, ) -> Result { key.validate()?; validate_policy(policy)?; - dimensions.validate_for_policy(policy)?; + let crate::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + } = policy.ring_dimension_schedule_mode + else { + return Err(AkitaError::InvalidSetup( + "unpruned traversal requires AdaptiveDimension policy".to_string(), + )); + }; let field_bits = policy.decomposition.field_bits(); let input_witness_len = 1usize.checked_shl(key.num_vars() as u32).ok_or_else(|| { @@ -229,29 +257,39 @@ pub(super) fn find_schedule( let mut complete = Vec::new(); let ctx = UnprunedCtx { policy, - dimensions, + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, ring_challenge_config: &ring_challenge_config, fold_shape: &fold_shape, 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; + for &root_d_a in potential_a_dimensions { + let root_dimensions = RingDimensionCandidate::Adaptive { + inner: root_d_a, + outer_dimensions: potential_b_dimensions, + opening_dimensions: potential_d_dimensions, + ceiling: CommitmentRingDims::uniform(policy.ring_dimension), + }; + let alpha = root_d_a.trailing_zeros() as usize; let reduced_vars = key.num_vars().saturating_sub(alpha); if reduced_vars == 0 { continue; } let min_block_bits = if reduced_vars >= 3 { 1 } else { 0 }; let max_block_bits = (reduced_vars - 1).min(usize::BITS as usize - 1); - let Ok(ring_challenge) = ring_challenge_config(root_dimensions.d_a()) else { + let Ok(ring_challenge) = ring_challenge_config(root_d_a) else { continue; }; for block_bits in min_block_bits..=max_block_bits { let Some(root_params) = scalar_root_fold_level_params_candidate( policy, &ring_challenge, - *root_dimensions, + root_dimensions, key.num_vars(), key.num_polynomials(), log_basis, @@ -289,7 +327,7 @@ pub(super) fn find_schedule( 0, key, input_witness_len, - root_dimensions.d_a(), + root_d_a, )? else { continue; @@ -300,7 +338,11 @@ pub(super) fn find_schedule( level: 1, input_witness_len: output_witness_len, current_log_basis: log_basis, - dimension_ceiling: *root_dimensions, + dimension_ceiling: if num_search_levels <= 1 { + CommitmentRingDims::uniform(uniform_suffix_dimension) + } else { + root_params.role_dims() + }, }, )? { let child_is_terminal = suffix.folds.is_empty(); @@ -350,24 +392,15 @@ pub(super) fn find_schedule( } } - let mut scored = complete + let complete = complete .into_iter() .filter(|candidate| { candidate.setup_field_elements <= policy.max_setup_envelope_field_elements }) - .map(|candidate| { - let descriptor = - candidate_schedule_descriptor_bytes(&candidate, policy.ring_dimension)?; - Ok(( - candidate.setup_field_elements, - candidate.total_bytes, - descriptor, - candidate, - )) - }) - .collect::, AkitaError>>()?; - scored.sort_by(|left, right| (&left.0, &left.1, &left.2).cmp(&(&right.0, &right.1, &right.2))); - let Some((_, _, _, selected)) = scored.into_iter().next() else { + .collect(); + let Some(selected) = + select_adaptive_candidate(complete, num_search_levels, policy.ring_dimension)? + else { return Err(AkitaError::UnsupportedSchedule( "unpruned traversal found no complete schedule".into(), )); diff --git a/crates/akita-schedules/src/candidate.rs b/crates/akita-schedules/src/candidate.rs index 4b62a1e88..ad3dca3c7 100644 --- a/crates/akita-schedules/src/candidate.rs +++ b/crates/akita-schedules/src/candidate.rs @@ -6,12 +6,125 @@ use akita_challenges::{SparseChallengeConfig, TensorChallengeShape}; use akita_field::AkitaError; use akita_types::sis::{ decomposed_s_block_ring_count, decomposed_t_ring_count, decomposed_w_ring_count, - num_digits_inner, num_digits_open, projected_role_ring_count, rounded_up_collision_inf_norm, - rounded_up_role_a_inf_norm, HonestFoldPolicy, HonestFoldPolicySpec, HonestFoldSizingQuery, - InnerCommitMatrixParams, OpenCommitMatrixParams, OuterCommitMatrixParams, SisTableKey, + min_secure_rank, num_digits_inner, num_digits_open, projected_role_ring_count, + rounded_up_collision_inf_norm, rounded_up_role_a_inf_norm, HonestFoldPolicy, + HonestFoldPolicySpec, HonestFoldSizingQuery, InnerCommitMatrixParams, OpenCommitMatrixParams, + OuterCommitMatrixParams, SisTableKey, }; use akita_types::{CommitmentRingDims, CommittedGroupParams, DecompositionParams, SisMatrixRole}; +/// Ring-dimension choice for one planner candidate. +#[derive(Clone, Copy, Debug)] +pub enum RingDimensionCandidate<'a> { + /// Use one exact A/B/D tuple. + Fixed(CommitmentRingDims), + /// Search has fixed A; derive B/D by minimum rank within the supplied + /// role domains and the previous level's monotonic ceiling. + Adaptive { + inner: usize, + outer_dimensions: &'a [usize], + opening_dimensions: &'a [usize], + ceiling: CommitmentRingDims, + }, +} + +impl RingDimensionCandidate<'_> { + /// Return the already-selected A dimension. + pub fn inner(self) -> usize { + match self { + Self::Fixed(dimensions) => dimensions.d_a(), + Self::Adaptive { inner, .. } => inner, + } + } + + 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(()) + } + } + } + + /// Select the B or D dimension for this candidate. + pub fn collision_role_price( + self, + policy: &PlannerPolicy, + role: SisMatrixRole, + native_width: usize, + log_basis: u32, + ) -> Option<(SisTableKey, usize)> { + let carrier_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, + carrier_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: Option<(usize, usize, SisTableKey, usize)> = None; + for &role_dimension in dimensions { + if role_dimension > carrier_dimension || role_dimension > role_ceiling { + continue; + } + let Some((key, width)) = projected_collision_role_price( + policy, + role, + carrier_dimension, + role_dimension, + native_width, + log_basis, + ) else { + continue; + }; + let Ok(width_u64) = u64::try_from(width) else { + continue; + }; + let Some(rank) = min_secure_rank(key, width_u64) else { + continue; + }; + 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)) + } + } + } +} + /// Build one scalar root-fold candidate for an explicit basis and split. /// /// `Ok(None)` is the canonical candidate-infeasibility signal used by schedule @@ -21,7 +134,7 @@ use akita_types::{CommitmentRingDims, CommittedGroupParams, DecompositionParams, pub fn scalar_root_fold_level_params_candidate( policy: &PlannerPolicy, ring_challenge_cfg: &SparseChallengeConfig, - dimensions: CommitmentRingDims, + dimensions: RingDimensionCandidate<'_>, num_vars: usize, num_claims: usize, log_basis: u32, @@ -29,8 +142,9 @@ pub fn scalar_root_fold_level_params_candidate( requested_fold_shape: TensorChallengeShape, honest_fold_policy: HonestFoldPolicySpec, ) -> Result, AkitaError> { - dimensions.validate_role_projection()?; - let alpha = (dimensions.d_a() as u32).trailing_zeros() as usize; + dimensions.validate()?; + let d_a = dimensions.inner(); + let alpha = (d_a as u32).trailing_zeros() as usize; let reduced_vars = num_vars.saturating_sub(alpha); if reduced_vars == 0 || block_index_bits >= reduced_vars { return Ok(None); @@ -69,13 +183,13 @@ pub fn scalar_root_fold_level_params_candidate( return Ok(None); }; let Some(num_fold_coeffs) = width_s - .checked_mul(dimensions.d_a()) + .checked_mul(d_a) .and_then(|count| count.checked_mul(root_num_chunks)) else { return Ok(None); }; let Ok(num_digits_fold) = honest_fold_policy.num_digits_fold(HonestFoldSizingQuery { - ring_dimension: dimensions.d_a(), + ring_dimension: d_a, num_claims, num_live_blocks, num_chunks: root_num_chunks, @@ -90,7 +204,7 @@ pub fn scalar_root_fold_level_params_candidate( policy.sis_security_policy, policy.sis_table_digest, policy.sis_modulus_profile, - dimensions.d_a(), + d_a, log_basis, ring_challenge_cfg, fold_challenge_shape, @@ -100,7 +214,7 @@ pub fn scalar_root_fold_level_params_candidate( return Ok(None); }; let Ok(inner_commit_matrix) = InnerCommitMatrixParams::try_new_with_min_rank( - sis_key_at_dimension(policy, SisMatrixRole::Inner, dimensions.d_a(), norm_s), + sis_key_at_dimension(policy, SisMatrixRole::Inner, d_a, norm_s), width_s, ) else { return Ok(None); @@ -113,14 +227,9 @@ pub fn scalar_root_fold_level_params_candidate( ) else { return Ok(None); }; - let Some((outer_key, width_t)) = projected_collision_role_price( - policy, - SisMatrixRole::Outer, - dimensions.d_a(), - dimensions.d_b(), - native_width_t, - log_basis, - ) else { + let Some((outer_key, width_t)) = + dimensions.collision_role_price(policy, SisMatrixRole::Outer, native_width_t, log_basis) + else { return Ok(None); }; let Ok(outer_commit_matrix) = @@ -133,14 +242,9 @@ pub fn scalar_root_fold_level_params_candidate( else { return Ok(None); }; - let Some((open_key, width_w)) = projected_collision_role_price( - policy, - SisMatrixRole::Open, - dimensions.d_a(), - dimensions.d_d(), - native_width_w, - log_basis, - ) else { + let Some((open_key, width_w)) = + dimensions.collision_role_price(policy, SisMatrixRole::Open, native_width_w, log_basis) + else { return Ok(None); }; let Ok(open_commit_matrix) = OpenCommitMatrixParams::try_new_with_min_rank(open_key, width_w) diff --git a/crates/akita-schedules/src/catalog_identity.rs b/crates/akita-schedules/src/catalog_identity.rs index 58359d8ce..96f915b2f 100644 --- a/crates/akita-schedules/src/catalog_identity.rs +++ b/crates/akita-schedules/src/catalog_identity.rs @@ -21,7 +21,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())); @@ -49,7 +49,7 @@ pub fn policy_digest(policy: &PlannerPolicy) -> [u8; 32] { h.write_u64(u64::from(policy.sis_security_policy.tag())); h.write_bytes(&policy.sis_table_digest.0); h.write_u64(policy.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); @@ -103,7 +103,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); @@ -147,7 +147,7 @@ struct CatalogIdentityExpectation { recursive_setup_planning: bool, root_fold_shape: TensorChallengeShape, - ring_dimension_candidates: Vec, + ring_dimension_schedule_mode: RingDimensionScheduleMode, ring_dimensions: Vec, ring_challenge_config_digest: u64, key_count: usize, @@ -177,7 +177,7 @@ impl CatalogIdentityExpectation { recursive_setup_planning: identity.recursive_setup_planning, root_fold_shape: identity.root_fold_shape, - 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, @@ -190,12 +190,6 @@ 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, @@ -204,10 +198,9 @@ fn catalog_identity_expectation( fold_challenge_shape_at_level: impl Fn(AkitaScheduleInputs) -> TensorChallengeShape, ) -> Result { let root_fold_shape = root_fold_shape_for_entries(entries, &fold_challenge_shape_at_level)?; - 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 { @@ -230,7 +223,7 @@ fn catalog_identity_expectation( recursive_setup_planning: policy.recursive_setup_planning, root_fold_shape, - ring_dimension_candidates, + ring_dimension_schedule_mode: policy.ring_dimension_schedule_mode, ring_dimensions, ring_challenge_config_digest, key_count: entries.len(), @@ -274,9 +267,7 @@ pub fn expected_catalog_identity( recursive_setup_planning: expected.recursive_setup_planning, root_fold_shape: expected.root_fold_shape, - 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, @@ -361,7 +352,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 { @@ -460,48 +451,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 dimension D{terminal_d} is not the policy suffix D{expected_terminal} for key {:?}", entry.root.final_group.layout ))); } @@ -509,6 +506,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 the catalog 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); @@ -620,12 +657,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/fp128_d256_onehot.rs b/crates/akita-schedules/src/generated/fp128_d256_onehot.rs index c459f2502..7220a003d 100644 --- a/crates/akita-schedules/src/generated/fp128_d256_onehot.rs +++ b/crates/akita-schedules/src/generated/fp128_d256_onehot.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, PlannerCostModelId, PolynomialGroupLayout, - SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, - TensorChallengeShape, + RingDimensionScheduleMode, SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, + SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -128,8 +128,6 @@ pub(crate) static FP128_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] @@ -152,7 +150,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - 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: 9, diff --git a/crates/akita-schedules/src/generated/mod.rs b/crates/akita-schedules/src/generated/mod.rs index a75606faf..4458e761f 100644 --- a/crates/akita-schedules/src/generated/mod.rs +++ b/crates/akita-schedules/src/generated/mod.rs @@ -159,9 +159,8 @@ pub struct GeneratedScheduleCatalogIdentity { pub recursive_setup_planning: bool, pub root_fold_shape: akita_challenges::TensorChallengeShape, - /// 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, @@ -180,7 +179,7 @@ pub mod validate; pub(crate) mod walk; pub use crate::{ ChunkedWitnessCfg, CommitmentRingDims, DecompositionParams, PlannerCostModelId, - SelectionPolicyId, SisSecurityPolicyId, TensorChallengeShape, + RingDimensionScheduleMode, SelectionPolicyId, SisSecurityPolicyId, TensorChallengeShape, }; pub use akita_types::{ CommittedGroupProfile, InnerCommitMatrixParams, OuterCommitMatrixParams, PolynomialGroupLayout, @@ -341,79 +340,6 @@ fn precommitted_group_key_eq( generated == layout } -#[cfg(test)] -mod mixed_dimension_key_tests { - use super::{precommitted_group_key_eq, precommitted_group_sort_key}; - use akita_types::{ - CommittedGroupProfile, InnerCommitMatrixParams, OuterCommitMatrixParams, - PolynomialGroupLayout, SisModulusProfileId, SisTableDigest, - }; - - fn descriptor() -> CommittedGroupProfile { - CommittedGroupProfile { - version: CommittedGroupProfile::VERSION, - group: PolynomialGroupLayout::new(12, 1), - num_live_ring_elements_per_claim: 32, - num_positions_per_block: 8, - num_live_blocks: 4, - log_basis_inner: 4, - num_digits_inner: 2, - inner_commit_matrix: InnerCommitMatrixParams::new_unchecked( - akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, - SisTableDigest::CURRENT, - SisModulusProfileId::Q128OffsetA7F7, - 3, - 16, - 7, - 128, - ), - log_basis_outer: 5, - num_digits_outer: 2, - outer_commit_matrix: OuterCommitMatrixParams::new_unchecked( - akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, - SisTableDigest::CURRENT, - SisModulusProfileId::Q128OffsetA7F7, - 2, - 48, - 11, - 64, - ), - } - } - - #[test] - fn precommitted_key_identity_includes_both_native_ring_dimensions() { - let base = descriptor(); - let mut changed_inner = base; - changed_inner.inner_commit_matrix = InnerCommitMatrixParams::new_unchecked( - akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, - SisTableDigest::CURRENT, - SisModulusProfileId::Q128OffsetA7F7, - 3, - 16, - 7, - 64, - ); - let mut changed_outer = base; - changed_outer.outer_commit_matrix = OuterCommitMatrixParams::new_unchecked( - akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, - SisTableDigest::CURRENT, - SisModulusProfileId::Q128OffsetA7F7, - 2, - 48, - 11, - 32, - ); - for changed in [changed_inner, changed_outer] { - assert!(!precommitted_group_key_eq(&base, &changed)); - assert_ne!( - precommitted_group_sort_key(&base), - precommitted_group_sort_key(&changed) - ); - } - } -} - /// Returns an error when the generated key does not match the runtime key. pub(crate) fn validate_entry_key( generated: &GeneratedFoldScheduleEntry, @@ -701,3 +627,76 @@ pub fn fp64_d256_onehot_table() -> GeneratedScheduleTable { } } // @generated schedule module wiring end + +#[cfg(test)] +mod mixed_dimension_key_tests { + use super::{precommitted_group_key_eq, precommitted_group_sort_key}; + use akita_types::{ + CommittedGroupProfile, InnerCommitMatrixParams, OuterCommitMatrixParams, + PolynomialGroupLayout, SisModulusProfileId, SisTableDigest, + }; + + fn descriptor() -> CommittedGroupProfile { + CommittedGroupProfile { + version: CommittedGroupProfile::VERSION, + group: PolynomialGroupLayout::new(12, 1), + num_live_ring_elements_per_claim: 32, + num_positions_per_block: 8, + num_live_blocks: 4, + log_basis_inner: 4, + num_digits_inner: 2, + inner_commit_matrix: InnerCommitMatrixParams::new_unchecked( + akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, + SisTableDigest::CURRENT, + SisModulusProfileId::Q128OffsetA7F7, + 3, + 16, + 7, + 128, + ), + log_basis_outer: 5, + num_digits_outer: 2, + outer_commit_matrix: OuterCommitMatrixParams::new_unchecked( + akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, + SisTableDigest::CURRENT, + SisModulusProfileId::Q128OffsetA7F7, + 2, + 48, + 11, + 64, + ), + } + } + + #[test] + fn precommitted_key_identity_includes_both_native_ring_dimensions() { + let base = descriptor(); + let mut changed_inner = base; + changed_inner.inner_commit_matrix = InnerCommitMatrixParams::new_unchecked( + akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, + SisTableDigest::CURRENT, + SisModulusProfileId::Q128OffsetA7F7, + 3, + 16, + 7, + 64, + ); + let mut changed_outer = base; + changed_outer.outer_commit_matrix = OuterCommitMatrixParams::new_unchecked( + akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, + SisTableDigest::CURRENT, + SisModulusProfileId::Q128OffsetA7F7, + 2, + 48, + 11, + 32, + ); + for changed in [changed_inner, changed_outer] { + assert!(!precommitted_group_key_eq(&base, &changed)); + assert_ne!( + precommitted_group_sort_key(&base), + precommitted_group_sort_key(&changed) + ); + } + } +} diff --git a/crates/akita-schedules/src/lib.rs b/crates/akita-schedules/src/lib.rs index c3604f0a1..1b68bbab4 100644 --- a/crates/akita-schedules/src/lib.rs +++ b/crates/akita-schedules/src/lib.rs @@ -26,7 +26,7 @@ pub use resolve::{ }; pub use runtime::{ default_sis_security_policy, suffix_opening_layout, PlannerCostModelId, PlannerPolicy, - RuntimeSchedulePolicy, SelectionPolicyId, + RingDimensionScheduleMode, RuntimeSchedulePolicy, SelectionPolicyId, }; /// Shared schedule-construction primitives used by offline search and generated-row replay. @@ -34,7 +34,7 @@ pub use runtime::{ pub mod planner_support { pub use crate::candidate::{ projected_collision_role_price, scalar_root_fold_level_params_candidate, - sis_key_at_dimension, + sis_key_at_dimension, RingDimensionCandidate, }; pub use crate::runtime::{ checked_power_of_two_vars, grouped_segment_rings, materialize_candidate_schedule, diff --git a/crates/akita-schedules/src/runtime.rs b/crates/akita-schedules/src/runtime.rs index a3350f015..a6f3e3577 100644 --- a/crates/akita-schedules/src/runtime.rs +++ b/crates/akita-schedules/src/runtime.rs @@ -42,23 +42,23 @@ pub enum SelectionPolicyId { MinEstimatedProofPayload, /// Pick the first direct setup footprint, then payload, within setup support. MinFirstDirectSetupThenPayloadWithinSupportedEnvelope, - /// Pick exact physical setup fields, then exact proof payload bytes. - MinSetupMatrixFieldElementsThenProofPayload, + /// Pick per-level A rank/dimension, then setup fields and proof payload. + MinAdaptiveARankDimensionThenSetupAndProof, } impl SelectionPolicyId { /// Canonical selection objective for one schedule policy shape. pub fn for_policy( recursive_setup_planning: bool, - setup_generation_dimension: usize, - ring_dimension_candidates: &[CommitmentRingDims], + ring_dimension_schedule_mode: RingDimensionScheduleMode, ) -> Self { if recursive_setup_planning { Self::MinFirstDirectSetupThenPayloadWithinSupportedEnvelope - } else if ring_dimension_candidates - != [CommitmentRingDims::uniform(setup_generation_dimension)] - { - Self::MinSetupMatrixFieldElementsThenProofPayload + } else if matches!( + ring_dimension_schedule_mode, + RingDimensionScheduleMode::AdaptiveDimension { .. } + ) { + Self::MinAdaptiveARankDimensionThenSetupAndProof } else { Self::MinEstimatedProofPayload } @@ -69,7 +69,7 @@ impl SelectionPolicyId { match self { Self::MinEstimatedProofPayload => 1, Self::MinFirstDirectSetupThenPayloadWithinSupportedEnvelope => 2, - Self::MinSetupMatrixFieldElementsThenProofPayload => 3, + Self::MinAdaptiveARankDimensionThenSetupAndProof => 4, } } @@ -80,13 +80,62 @@ impl SelectionPolicyId { Self::MinFirstDirectSetupThenPayloadWithinSupportedEnvelope => { "MinFirstDirectSetupThenPayloadWithinSupportedEnvelope" } - Self::MinSetupMatrixFieldElementsThenProofPayload => { - "MinSetupMatrixFieldElementsThenProofPayload" + Self::MinAdaptiveARankDimensionThenSetupAndProof => { + "MinAdaptiveARankDimensionThenSetupAndProof" } } } } +/// Catalog-bound ring-dimension schedule policy. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum RingDimensionScheduleMode { + /// Use one uniform A/B/D dimension from the root through the terminal. + UniformDimension { + /// Shared A/B/D ring dimension. + ring_dimension: usize, + }, + /// Search A dimensions over a bounded leading prefix and derive B/D by + /// minimum secure rank before switching to one uniform suffix dimension. + AdaptiveDimension { + /// Number of leading fold levels at which A dimensions are searched. + num_search_levels: usize, + /// Uniform A/B/D dimension used after the searched prefix. + uniform_suffix_dimension: usize, + /// Canonically ordered A dimensions admitted by offline search. + potential_a_dimensions: &'static [usize], + /// Canonically ordered B dimensions scanned by minimum secure rank. + potential_b_dimensions: &'static [usize], + /// Canonically ordered D dimensions scanned by minimum secure rank. + potential_d_dimensions: &'static [usize], + }, +} + +impl RingDimensionScheduleMode { + /// Uniform dimensions for a uniform policy, if this is one. + #[must_use] + pub const fn uniform_dimensions(self) -> Option { + match self { + Self::UniformDimension { ring_dimension } => { + Some(CommitmentRingDims::uniform(ring_dimension)) + } + Self::AdaptiveDimension { .. } => None, + } + } + + /// A dimensions whose challenge hooks are part of catalog identity. + #[must_use] + pub const fn potential_a_dimensions(self) -> &'static [usize] { + match self { + Self::UniformDimension { ring_dimension: _ } => &[], + Self::AdaptiveDimension { + potential_a_dimensions, + .. + } => potential_a_dimensions, + } + } +} + /// Runtime schedule validation policy. /// /// The compatibility name stays `PlannerPolicy` during the migration because @@ -99,11 +148,8 @@ pub struct PlannerPolicy { pub max_setup_envelope_field_elements: usize, pub min_offloaded_witness_contraction: usize, pub 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, @@ -156,8 +202,7 @@ impl PlannerPolicy { recursive_setup_planning: false, selection_policy: SelectionPolicyId::for_policy( false, - self.ring_dimension, - self.ring_dimension_candidates, + self.ring_dimension_schedule_mode, ), ..self } @@ -207,11 +252,10 @@ pub(crate) 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)?; + validate_ring_dimension_schedule_mode(policy)?; let expected_selection_policy = SelectionPolicyId::for_policy( policy.recursive_setup_planning, - policy.ring_dimension, - policy.ring_dimension_candidates, + policy.ring_dimension_schedule_mode, ); if policy.selection_policy != expected_selection_policy { return Err(AkitaError::InvalidSetup( @@ -238,34 +282,101 @@ pub fn validate_policy(policy: &PlannerPolicy) -> Result<(), AkitaError> { Ok(()) } -fn validate_ring_dimension_candidates(policy: &PlannerPolicy) -> Result<(), AkitaError> { +fn validate_ring_dimension_schedule_mode(policy: &PlannerPolicy) -> Result<(), AkitaError> { if policy.ring_dimension == 0 || !policy.ring_dimension.is_power_of_two() { return Err(AkitaError::InvalidSetup( "setup generation dimension must be a nonzero power of two".to_string(), )); } - let candidates = policy.ring_dimension_candidates; - if candidates.is_empty() { - return Err(AkitaError::InvalidSetup( - "ring-dimension candidate domain must be nonempty".to_string(), - )); - } - let key = |dims: CommitmentRingDims| (dims.d_a(), dims.d_b(), dims.d_d()); - for (index, &dims) in candidates.iter().enumerate() { - dims.validate_role_projection()?; - for d in [dims.d_a(), dims.d_b(), dims.d_d()] { - if !policy.ring_dimension.is_multiple_of(d) { + match policy.ring_dimension_schedule_mode { + RingDimensionScheduleMode::UniformDimension { ring_dimension } => { + validate_dimension(policy.ring_dimension, "uniform", ring_dimension)?; + if ring_dimension != policy.ring_dimension { return Err(AkitaError::InvalidSetup(format!( - "candidate dimension D{d} does not divide setup generation D{}", + "uniform schedule D{ring_dimension} must equal setup generation D{}", policy.ring_dimension ))); } } - 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(), - )); + RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + } => { + if num_search_levels == 0 || num_search_levels > MAX_RECURSION_DEPTH { + return Err(AkitaError::InvalidSetup(format!( + "adaptive A search levels must be in 1..={MAX_RECURSION_DEPTH}, got {num_search_levels}" + ))); + } + validate_dimension( + policy.ring_dimension, + "uniform suffix", + uniform_suffix_dimension, + )?; + for (name, dimensions) in [ + ("A", potential_a_dimensions), + ("B", potential_b_dimensions), + ("D", potential_d_dimensions), + ] { + validate_dimension_list(policy.ring_dimension, name, dimensions)?; + if !dimensions.contains(&uniform_suffix_dimension) { + return Err(AkitaError::InvalidSetup(format!( + "adaptive {name} dimension domain must contain uniform suffix D{uniform_suffix_dimension}" + ))); + } + } + for (name, dimensions) in [ + ("A", potential_a_dimensions), + ("B", potential_b_dimensions), + ("D", potential_d_dimensions), + ] { + if dimensions.iter().any(|&d| d < uniform_suffix_dimension) { + return Err(AkitaError::InvalidSetup(format!( + "adaptive {name} dimensions must be at least the uniform suffix dimension" + ))); + } + } + } + } + Ok(()) +} + +fn validate_dimension( + setup_generation_dimension: usize, + label: &str, + dimension: usize, +) -> Result<(), AkitaError> { + if dimension == 0 || !dimension.is_power_of_two() { + return Err(AkitaError::InvalidSetup(format!( + "{label} ring dimension must be a nonzero power of two, got {dimension}" + ))); + } + if !setup_generation_dimension.is_multiple_of(dimension) { + return Err(AkitaError::InvalidSetup(format!( + "{label} dimension D{dimension} does not divide setup generation D{setup_generation_dimension}" + ))); + } + Ok(()) +} + +fn validate_dimension_list( + setup_generation_dimension: usize, + role: &str, + dimensions: &[usize], +) -> Result<(), AkitaError> { + if dimensions.is_empty() { + return Err(AkitaError::InvalidSetup(format!( + "adaptive {role} dimension domain must be nonempty" + ))); + } + for (index, &dimension) in dimensions.iter().enumerate() { + validate_dimension(setup_generation_dimension, role, dimension)?; + if index > 0 && dimensions[index - 1] >= dimension { + return Err(AkitaError::InvalidSetup(format!( + "adaptive {role} dimension domain must be strictly sorted and duplicate-free" + ))); } } Ok(()) diff --git a/specs/declarative-ring-dimension-policy.md b/specs/declarative-ring-dimension-policy.md new file mode 100644 index 000000000..8b19835ad --- /dev/null +++ b/specs/declarative-ring-dimension-policy.md @@ -0,0 +1,1235 @@ +# Declarative Ring-Dimension Schedule Policy + + +| Field | Value | +| ---------------------- | ------------------------------------------------------------------------------------------- | +| Status | Implemented | +| Revised | 2026-08-05 | +| Scope | Offline ring-dimension search, generated-catalog identity, and runtime replay | +| Related spec | `[mixed-ring-dimension-per-level.md](mixed-ring-dimension-per-level.md)` | +| Planner implementation | `[crates/akita-planner/src/schedule_params/](../crates/akita-planner/src/schedule_params/)` | +| Configuration bridge | `[crates/akita-config/src/lib.rs](../crates/akita-config/src/lib.rs)` | + + +## Summary + +Akita represents ring-dimension behavior with one declarative enum: + +```text +RingDimensionScheduleMode = + UniformDimension + | AdaptiveDimension +``` + +`UniformDimension` uses one uniform ring dimension for A, B, and D at every +fold and at the terminal. + +`AdaptiveDimension` performs a bounded brute-force search over potential A-ring +dimensions at a configured number of leading fold levels. A dimensions must +be non-increasing between adjacent searched levels. Each complete A-dimension +path first receives its best preprocessing/proof geometry. The planner then +selects the path lexicographically by `(minimum secure A rank, A dimension)` at +each searched level: a strict rank reduction justifies increasing dimension, +rank one stops further growth, and an equal rank keeps the smaller dimension. +If no dimension reaches rank one, the smallest rank found remains valid. From +the end of the configured search window onward, every role uses one fixed +uniform suffix dimension. + +B and D dimensions are not branching planner choices. Once an A dimension, +block geometry, basis, and role-native width are known, the planner scans the +ordered supported dimensions for that role from smallest to largest. It keeps +trying larger dimensions while deriving the exact secure rank, stops early if +rank one is reached, and otherwise selects the dimension with the smallest rank +found. A B- or D-role rank greater than one is valid when the allowed role +dimensions cannot reduce it further. Equal-rank choices prefer the smaller +dimension. + +The planner evaluates all valid A-dimension paths within the bounded search +window, derives B/D and all matrix ranks canonically, and plans the complete +uniform suffix. It first selects the best complete geometry for each exact A +path by physical preprocessing fields, modeled proof bytes, and descriptor +bytes. It then compares those path representatives by the per-level A +rank/dimension rule above. + +With two searched levels, potential A dimensions including D64, D128, and D256, +and a uniform-D64 suffix, the search includes: + +```text +256/128/128 -> 64/64/64 -> uniform D64 suffix + +256/128/128 -> 128/64/64 -> uniform D64 suffix + +256/128/128 -> 256/64/64 -> uniform D64 suffix +``` + +The first path is the D256 direct transition, the second is the D256 +three-band transition, and the third retains D256 for A at L1. None needs to +be passed as an explicit topology. + +The policy is implemented in the runtime policy, offline planner, catalog +identity, generated-table emitter, and the fp128 one-hot adaptive preset. + +## Implementation status + +The implementation has the following shape: + +- `CommitmentConfig::RING_DIMENSION_SCHEDULE_MODE` is the single configuration + input. The former tuple-valued config field and separate public search-domain + object are removed. +- `find_schedule` dispatches from the enum. Uniform policies reuse the existing + uniform suffix DP. Adaptive policies run the bounded leading-level frontier + and then rejoin the uniform suffix derivation. +- Root and recursive candidate construction share one + `RingDimensionCandidate` implementation. It fixes A for a search branch and + derives B/D from the canonical projected width and SIS table. +- Complete schedules are grouped by their exact A-dimension path. Setup/proof + scoring chooses one representative per path before representatives are + compared by per-level A rank and dimension. +- Generated catalog identity stores the complete enum value and all three + ordered adaptive capability lists. Challenge-hook identity covers every A + candidate, including non-winners. +- `MixedDimFp128OneHot` uses two searched levels, a D64 uniform suffix, A + candidates `[64, 128, 256]`, and B/D candidates `[64, 128]`. +- Adaptive direct multi-chunk and recursive-setup planning remain rejected as + specified. Scalar dispatch through a recursive adapter first applies its + direct-only policy and is therefore supported. + +The adaptive orchestration remains in `mixed_search.rs`, but it is no longer a +second public configuration/search API and contains no preset-name dispatch. +Its matrix construction, SIS pricing, setup accounting, proof pricing, and +materialization all call the same canonical primitives as uniform planning. +An unpruned adaptive traversal remains test-only and checks that frontier +pruning selects the same descriptor and estimate. + +## Decisions + +This revision makes the following decisions: + +1. Use `RingDimensionScheduleMode` with exactly two modes: + `UniformDimension` and `AdaptiveDimension`. +2. Brute-force A dimensions only. +3. Restrict A brute force to an explicit number of leading levels. +4. Require A to be smaller than or equal to the preceding A dimension between + adjacent searched levels. +5. Use a configured uniform suffix dimension after the search window. +6. Do not branch over B or D dimensions. +7. Derive B and D independently by scanning supported dimensions from smallest + to largest and minimizing exact secure rank. +8. Stop a B/D scan early at rank one; if no rank-one dimension exists, retain + the dimension with the lowest rank found, preferring the smaller dimension + on a rank tie. +9. For each exact A-dimension path, select its complete schedule by physical + preprocessing matrix fields, then proof bytes, then descriptor bytes. +10. Select among those path representatives by the lexicographic per-level + `(A rank, A dimension)` vector. Rank one is an early stop; if it is + unavailable, the smallest rank wins. +11. Keep all planner work offline and runtime schedule selection catalog-only. + +## Goals + +1. Find the smallest secure A rank over a small, explicit dimension domain + without sacrificing the best geometry available to each dimension path. +2. Avoid the much larger Cartesian search over A, B, D, and cross-level role + tuples. +3. Keep dimension search bounded by configuration rather than planner constants. +4. Preserve canonical security sizing and verifier-visible schedule data. +5. Admit both D256 direct and D256 three-band paths naturally. +6. Remove planner logic specialized to the name `MixedDimFp128OneHot`. +7. Preserve deterministic generation across machines and executions. + +## Non-goals + +- The planner does not brute-force B dimensions. +- The planner does not brute-force D dimensions. +- The planner does not search adaptive dimensions after the configured level +window. +- The planner does not reject an A path merely because no allowed dimension + reaches rank one. +- The planner does not optimize measured commit, prove, or verify wall time. +- Runtime proving and verification do not invoke the planner. +- Uniform D512 B/D commitments are not made valid by this policy. +- Mixed recursive-setup and mixed multi-chunk planning are not automatically +enabled. + +## Terminology and dimensions + +### Setup-generation dimension + +The setup-generation dimension is the ring dimension used to derive and store +the shared preprocessing matrix. It is currently represented by +`CommitmentConfig::D`. + +It is separate from the role dimensions used by a particular fold. Every +role-local ring dimension must divide the setup-generation dimension. + +For example, a D256 setup may support D256, D128, and D64 role views, but it +cannot support a D512 role. + +### Commitment-role dimensions + +Every non-terminal fold has three dimensions: + +```text +d_a: inner A matrix, fold arithmetic, and A-native source ring +d_b: outer B matrix +d_d: opening D matrix +``` + +They are represented as: + +```text +CommitmentRingDims { + inner: d_a, + outer: d_b, + opening: d_d, +} +``` + +The A-native source is projected into B and D. Each selected tuple must satisfy: + +```text +d_b <= d_a +d_d <= d_a +d_a % d_b == 0 +d_a % d_d == 0 +``` + +B and D are selected independently. Neither role is ordered relative to the +other. + +### Searched level + +A searched level is a leading fold level at which the planner enumerates +potential A dimensions. + +If `num_search_levels = 2`, the search applies only to: + +```text +L0 and L1 +``` + +L2 and every later fold use the uniform suffix dimension. + +The terminal always uses the uniform suffix dimension. + +### Uniform suffix + +The uniform suffix begins at `num_search_levels`: + +```text +first_uniform_level = num_search_levels +``` + +For example: + +```text +num_search_levels = 2 +uniform_suffix_dimension = 64 + +L0: search A +L1: search the same or a smaller A +L2+: A/B/D = 64/64/64 +terminal: D64 +``` + +The suffix may equal the A dimension selected at the final searched level. This +is how the search represents a direct early transition such as: + +```text +L0 A256 +L1 A64 +L2+ uniform D64 +``` + +Non-increasing descent applies between adjacent searched levels: the next A may +be smaller or equal, but never larger. Once the uniform suffix begins, repeated +D64 levels are expected and obey the same monotonic rule. + +### Preprocessing matrix size + +The primary geometry objective inside each exact A-dimension path is the +largest physical base-field footprint of any setup matrix required by the +complete schedule: + +```text +setup_matrix_field_elements_for_schedule(schedule) +``` + +This is the canonical quantity comparable across mixed role dimensions and +different setup-generation dimensions. + +It is not: + +- the sum of all A/B/D matrices at all levels; +- the number of setup-generation ring elements without multiplying by their +physical field width; +- setup-seed serialization size; or +- observed resident memory. + +Akita stores one shared preprocessing vector. Role matrices are prefix views, +so the schedule requires an envelope equal to its largest physical matrix or +setup-prefix footprint. + +## Policy model + +The following is a semantic model, not final Rust syntax: + +```text +enum RingDimensionScheduleMode { + UniformDimension { + ring_dimension: usize, + }, + + AdaptiveDimension { + num_search_levels: usize, + uniform_suffix_dimension: usize, + potential_a_dimensions: &'static [usize], + potential_b_dimensions: &'static [usize], + potential_d_dimensions: &'static [usize], + }, +} +``` + +The setup-generation dimension remains a separate config/policy value. The +mode is carried alongside the existing decomposition policy, SIS identity, +challenge hooks, basis range, chunk policy, recursive-setup policy, setup cap, +and selection policy. + +### UniformDimension + +`UniformDimension` defines one topology: + +```text +L0 through terminal: + d_a = d_b = d_d = ring_dimension +``` + +Examples: + +```text +UniformDimension { ring_dimension: 64 } +UniformDimension { ring_dimension: 128 } +``` + +This mode performs no dimension search. It should preserve existing uniform +schedule descriptors and estimates when all other policy inputs are unchanged. + +### AdaptiveDimension + +`AdaptiveDimension` defines a bounded A search and deterministic B/D derivation. + +An initial fp128 one-hot policy may use: + +```text +AdaptiveDimension { + num_search_levels: 2, + uniform_suffix_dimension: 64, + potential_a_dimensions: [64, 128, 256, 512], + potential_b_dimensions: [64, 128], + potential_d_dimensions: [64, 128], +} +``` + +D512 remains subject to the additional setup-generation and honest-fold +requirements described later. A D256 setup must filter or reject D512 rather +than attempting to search it. + +The lists are role capability domains, not complete A/B/D tuple candidates. +A produces search branches. B and D lists are scanned deterministically after +the A-dependent physical widths are known. + +## Bounded A-dimension brute force + +### Search domain + +At every searched level, the planner considers each supported A dimension that: + +1. is a nonzero power of two; +2. divides the setup-generation dimension; +3. has ring-challenge and fold-arithmetic support; +4. has the required A-role SIS coverage for the derived width and bound; +5. is at least the uniform suffix dimension; and +6. is no larger than the A dimension at the preceding searched level. + +At the root there is no preceding A dimension. The setup-generation dimension +is a capability ceiling, not a required root choice. + +For searched levels `i > 0`: + +```text +d_a[i] <= d_a[i - 1] +``` + +At the boundary to the fixed suffix: + +```text +uniform_suffix_dimension <= d_a[last searched level] +``` + +Equality at the boundary is allowed because the final searched level may have +already transitioned to the suffix dimension. + +### Exact bounded depth + +The planner must not continue A-dimension search after: + +```text +level == num_search_levels - 1 +``` + +At: + +```text +level == num_search_levels +``` + +the only allowed tuple is: + +```text +uniform_suffix_dimension / uniform_suffix_dimension / uniform_suffix_dimension +``` + +This bound is part of catalog identity. Changing it changes the search policy +even if the winning rows happen to remain the same. + +### Search size + +Because A must be non-increasing, the A search is smaller than an unrestricted +per-level product while retaining schedules that keep the same A dimension for +multiple leading folds. + +For four ordered A dimensions and two searched levels, the complete +non-increasing A paths are: + +```text +512 -> 512 +512 -> 256 +512 -> 128 +512 -> 64 +256 -> 256 +256 -> 128 +256 -> 64 +128 -> 128 +128 -> 64 +64 -> 64 +``` + +Protocol support, setup divisibility, contraction, SIS availability, and setup +capacity may remove additional paths. + +The planner does not construct B/D branches for each of these A paths. + +### Block geometry and basis + +Brute-forcing A dimensions does not mean matrix parameters are copied from a +dimension-only table. For every A path, the planner still evaluates the +canonical basis and block-layout choices allowed by the configured planner +policy. + +The dependency remains: + +```text +A dimension + + current input witness + + basis + + block split + + challenge shape + -> A width, bound, and minimum secure rank + -> B/D native widths + -> deterministic B/D dimensions + -> exact outgoing witness + -> complete continuation +``` + +A path is not comparable until the complete schedule has been constructed and +priced. + +## Deterministic B and D dimension selection + +### No B/D search branches + +For one fixed A-level candidate, B and D are derived independently. Their +dimension alternatives do not create multiple child schedules. + +The planner scans each role's candidate list in ascending dimension order. It +tracks the supported dimension producing the smallest exact secure rank and +stops early only when rank one is reached: + +```text +choose_role_dimension(role, native_width, d_a, parent_role_ceiling): + best = None + + for d in potential_role_dimensions ascending: + skip unless d <= d_a + skip unless d divides d_a and setup generation + skip unless d <= parent_role_ceiling, when a parent exists + derive projected physical width at d + derive role-local coefficient bound at d + derive minimum secure SIS rank at d + + if best is None or (rank, d) < (best.rank, best.dimension): + best = d and the derived matrix parameters + + if rank == 1: + break + + return best, or candidate infeasible if no admissible matrix exists +``` + +This scan is a deterministic derivation rule, not planner branching: exactly +one B matrix and one D matrix survive for an A/geometry candidate. A secure +rank greater than one does not make the candidate infeasible. + +### Why selection occurs after A derivation + +B's native width depends on A's output rank. Both B and D physical widths +depend on projection from the selected A ring: + +```text +physical_B_width = native_B_width * (d_a / d_b) +physical_D_width = native_D_width * (d_a / d_d) +``` + +Therefore B/D dimensions cannot be selected from A dimension alone. The +planner must first derive the exact A matrix and level geometry. + +### B and D are independent + +The planner applies the minimum-rank scan independently: + +```text +d_b = supported B dimension minimizing (secure rank, dimension) +d_d = supported D dimension minimizing (secure rank, dimension) +``` + +Rank one is an early-stop condition because no larger dimension can improve the +rank below one. It is not a validity requirement. The policy does not require +`d_b == d_d`. + +### Cross-level role ceilings + +A is required to be non-increasing inside the search window. To preserve the +same monotonic transition contract, B and D must not increase: + +```text +d_b[level] <= d_b[level - 1] +d_d[level] <= d_d[level - 1] +``` + +The preceding selected role dimension is therefore a ceiling during the +deterministic scan. If admissible dimensions exist but all produce rank greater +than one, the scan keeps the smallest rank among them. The A/geometry candidate +is infeasible only when no admissible, SIS-supported role matrix exists. + +At the uniform suffix boundary: + +```text +suffix_dimension <= final d_a +suffix_dimension <= final d_b +suffix_dimension <= final d_d +``` + +If these inequalities do not hold, the candidate cannot transition to the +configured suffix. + +### A rank minimization and non-rank-one fallback + +A dimensions are globally searched, but rank comparison must not select an +inferior block geometry merely to lower rank. For each exact A-dimension path, +the planner first chooses that path's best complete schedule by setup fields, +proof bytes, and descriptor bytes. It then compares the resulting path +representatives by the per-level vector: + +```text +[(n_a[0], d_a[0]), (n_a[1], d_a[1]), ...] +``` + +The vector is compared lexicographically. At each searched level, a larger +dimension is useful only when it strictly lowers the minimum secure A rank. An +equal rank keeps the smaller dimension, and rank one prevents any larger +dimension from winning. If every allowed dimension has rank greater than one, +the smallest rank found remains valid. + +This fallback is necessary for workloads such as `nv=40`, where current D256 +coverage requires A rank two. Recursive and terminal A matrices also commonly +have ranks greater than one. B and D may likewise remain above rank one after +their deterministic scans exhaust the allowed dimensions. + +### Known tradeoff + +Choosing B/D by minimum secure rank, with smaller dimension as the tie-break, +is a policy simplification. It is not a proof that equal-rank dimensions are +globally equivalent in preprocessing size, proof bytes, or verifier work. + +This proposal accepts that limitation to avoid B/D brute force. The exact rule +must be catalog-bound so that generation and runtime replay agree. If later +measurements show that the simplification excludes important schedules, a new +selection policy may admit B/D branching explicitly. + +## Required D256 paths + +With: + +```text +num_search_levels = 2 +uniform_suffix_dimension = 64 +potential_a_dimensions containing 64, 128, and 256 +``` + +the A brute-force search must include: + +```text +A path 1: 256 -> 64 +A path 2: 256 -> 128 +A path 3: 256 -> 256 +``` + +For current fp128 one-hot widths, deterministic minimum-rank B/D selection is +expected to materialize the corresponding role topologies: + +```text +path 1: + L0: 256/128/128 + L1: 64/64/64 + L2+: 64/64/64 + +path 2: + L0: 256/128/128 + L1: 128/64/64 + L2+: 64/64/64 + +path 3: + L0: 256/128/128 + L1: 256/64/64 + L2+: 64/64/64 +``` + +The first is the D256 direct path. The second is the required D256 three-band +path: + +```text +256/128/128 -> 128/64/64 -> 64/64/64 +``` + +The dimensions above are expected outcomes, not hard-coded tuples. B/D must be +re-derived from each candidate's exact widths and minimum-rank scan. A regression +test should pin the topology for workloads where the current SIS table produces +these selections. + +The L1 matrices of the three-band path must be constructed from the exact +witness produced by its D256 root. They must not be copied from an independently +planned D128-root schedule. + +For the current `nv=36` representatives, the three L1 A ranks are: + +```text +D64 -> rank 5 +D128 -> rank 3 +D256 -> rank 2 +``` + +No allowed dimension reaches rank one, so path 3 is selected with rank two. + +## Selection objective + +### Per-path geometry objective + +For every valid complete A path and geometry, compute: + +```text +physical_preprocessing_fields = + setup_matrix_field_elements_for_schedule(schedule) +``` + +For each exact A-dimension path, select the schedule with the smallest value. + +The planner must not compare only `SetupMatrixEnvelope::max_setup_len`, because +that value counts setup-generation ring elements and is not directly comparable +across generation dimensions. + +### A-path selection and deterministic tie-breaking + +The complete selection is: + +```text +representative(path) = min_by( + physical_preprocessing_matrix_field_elements, + exact_modeled_proof_payload_bytes, + canonical_schedule_descriptor_bytes, +) + +winner = min_by( + per_level_(A_rank, A_dimension)_vector, + representative_setup_fields, + representative_proof_bytes, + representative_descriptor_bytes, +) +``` + +Optimizing each dimension path before comparing ranks is important. Otherwise, +the planner could choose an unnecessarily expensive block geometry solely +because that geometry happens to lower A rank. Proof bytes select among +schedules with equal preprocessing capacity inside a path. Descriptor bytes +make an exact cost tie deterministic. A-dimension enumeration order, hash-map +order, and thread scheduling must not affect the result. + +### Consequence for the D256-root paths + +Current measurements in the related mixed-dimension spec show that the D256 +direct and three-band schedules can have the same preprocessing footprint: + +```text +D256 direct: 45,088,768 fp128 field elements +D256 three-band: 45,088,768 fp128 field elements +``` + +Under the revised rank-first A-path policy, the path whose representative has +the smaller L1 A rank wins. At `nv=36`, the retained-D256 L1 has rank two and +therefore wins over the three-band rank-three and direct rank-five paths. Setup +and proof bytes decide only after the per-level rank/dimension vectors tie. + +The measured verifier-time advantage of one topology is not part of this +deterministic objective. Adding verifier work requires a separate versioned +cost model. + +### Setup capacity + +Any candidate exceeding the configured physical setup cap is infeasible. +Capacity is a feasibility constraint; it does not replace comparison among the +remaining schedules. + +## Complete adaptive search algorithm + +For one workload under `AdaptiveDimension`: + +1. Validate the search window, suffix dimension, and role capability lists. +2. Start at L0 with every supported A dimension. +3. For every root A dimension, basis, and feasible block split: + 1. Derive A width, coefficient bound, and minimum secure rank. + 2. Derive B's native width and select B by the deterministic minimum-rank + scan. + 3. Derive D's native width and select D by the deterministic minimum-rank + scan. + 4. Derive the exact outgoing witness and reject non-contraction. +4. At each later searched level: + 1. enumerate only A dimensions no larger than the preceding A; + 2. derive A from the exact incoming witness; + 3. derive B/D using the deterministic minimum-rank rule and parent ceilings; + 4. derive the exact outgoing witness; and + 5. retain the required setup/proof continuation frontier. +5. Stop A enumeration after exactly `num_search_levels` leading levels. +6. Transition to uniform `suffix/suffix/suffix`. +7. Use the canonical uniform suffix planner from the exact boundary witness. +8. Reject candidates that cannot transition, contract, terminate, satisfy SIS + coverage, or fit setup capacity. +9. Materialize each complete schedule and recompute exact setup/proof estimates. +10. Group complete schedules by their exact A-dimension path and select the + best geometry in each group by setup fields, proof bytes, and descriptor + bytes. +11. Compare the path representatives by their lexicographic per-level + `(A rank, A dimension)` vectors. A strict rank reduction wins; an equal rank + keeps the smaller dimension; rank one prevents further dimension growth; + and the smallest available rank remains valid when rank one is unavailable. + +An unsupported SIS cell for one B/D dimension causes the role scan to try the +next allowed dimension. An A/geometry candidate becomes infeasible when the +scan finds no admissible SIS-supported matrix for either role. Malformed config, +inconsistent catalog identity, invalid dimension arithmetic, or an invalid +capability list is a policy error. If all candidates are infeasible, the +workload is unsupported. + +## Frontier and memoization requirements + +### Non-additive setup objective + +Setup and proof costs compose differently: + +```text +combined.setup = max(level.setup, child.setup) +combined.proof = level.proof + child.proof +``` + +The planner cannot retain only one locally best suffix. A larger parent may +mask two child setup footprints, after which the child with fewer proof bytes +wins. + +The planner must retain the nondominated setup/proof alternatives needed by the +complete-schedule objective, partitioned by exact first-child parameters where +parent proof pricing depends on them. + +### Adaptive memo state + +The memo state must distinguish at least: + +```text +level +input witness length +current basis +previous A dimension +previous selected B dimension +previous selected D dimension +remaining searched levels or absolute boundary +``` + +Once the search enters the uniform suffix, dimension state canonicalizes to the +configured suffix dimension and can reuse the ordinary uniform suffix state. + +### B/D derivation and memoization + +B/D choices need not be stored as alternative branches, but their selected +dimensions are parent-visible transition ceilings and part of the exact fold +descriptor. Memo keys or state partitioning must not merge suffixes reached +through incompatible B/D selections. + +## Validation requirements + +### Mode validation + +- `UniformDimension.ring_dimension` is a nonzero supported power of two and, + in the current uniform engine, equals the setup-generation dimension. +- `AdaptiveDimension.num_search_levels` is positive. +- The uniform suffix dimension is a nonzero supported power of two. +- Each potential dimension list is nonempty, sorted, and unique. +- Every potential dimension divides the setup-generation dimension or is +rejected as incompatible with that config. +- The suffix dimension appears in all three role capability domains, and no + listed role dimension is smaller than the suffix. + +### A-domain validation + +- Every A dimension has challenge and fold support. +- Every A dimension is at least the suffix dimension. +- The domain contains at least one A dimension at or above the suffix +dimension. +- Search never increases A inside the configured search window; repeating the +preceding A dimension is allowed. + +### B/D-domain validation + +- Every B/D dimension has role-local SIS and execution support. +- D512 must not be inferred for B or D merely because it appears in the A list. +- B and D domains may differ. +- The deterministic ascending minimum-rank rule and its rank-one early stop are +bound into policy identity. + +### Transition validation + +Inside the search window: + +```text +child.d_a <= parent.d_a +child.d_b <= parent.d_b +child.d_d <= parent.d_d +``` + +At the suffix boundary: + +```text +suffix <= parent.d_a +suffix <= parent.d_b +suffix <= parent.d_d +``` + +After the boundary, every fold and terminal use the uniform suffix dimension. + +## D512 policy + +D512 may appear in `potential_a_dimensions`, but only when the surrounding +policy supports it. + +### Setup generation + +A D512 role requires a setup-generation dimension divisible by 512. A current +D256 mixed setup cannot admit D512. + +### Role support + +Current fp128 support treats D512 as an A-role experiment. It does not certify +uniform D512 B/D matrices. Therefore an initial adaptive policy may use: + +```text +potential_a_dimensions = [64, 128, 256, 512] +potential_b_dimensions = [64, 128] +potential_d_dimensions = [64, 128] +``` + +It must not derive `512/512/512`. + +### Honest-fold sizing + +Current D256 and D512 one-hot presets use different root honest-fold norm +inputs. Combining them in one A search requires either: + +- a dimension-dependent honest-fold sizing hook; or +- one conservative policy proven valid across the complete A domain. + +Until setup generation and honest-fold sizing are resolved, D512 must be +filtered from configs that cannot support it rather than producing a partially +valid search. + +## Current `mixed_search.rs` boundary + +### Why it exists + +`find_schedule` now dispatches directly from the catalog-bound enum: + +```text +UniformDimension -> find_schedule_inner +AdaptiveDimension -> mixed_search::find_schedule +``` + +The uniform suffix DP assumes one dimension throughout its state. The adaptive +orchestration module adds: + +- per-level dimension state; +- component-wise transition ceilings; +- candidate-local A challenges; +- the forced uniform suffix boundary; +- prevention of early terminal selection; +- setup/proof frontier retention; and +- per-path geometry selection followed by rank-first A-path selection. + +The module is search orchestration, not a separate source of matrix security or +protocol geometry. It calls canonical candidate, SIS, proof-size, witness, and +setup primitives. + +### Consolidation under the enum + +The public design uses one topology-aware planner entry point: + +```text +find_schedule(policy) + -> UniformDimension: one fixed uniform path + -> AdaptiveDimension: bounded non-increasing A search with derived B/D +``` + +Root and recursive matrix construction, termination, materialization, and exact +estimate revalidation are shared. The adaptive module owns only the additional +A-path/frontier state and the transition to the existing uniform suffix. + +The preprocessing-first objective applies inside every exact A path. Comparing +A ranks before selecting a path representative would be incorrect because it +could distort block geometry solely to obtain a lower rank. Once every path has +its canonical representative, per-level A rank/dimension comparison selects +among paths. + +Moving the remaining adaptive frontier into the uniform suffix engine is an +optional internal consolidation. `mixed_search.rs` may be removed only when: + +1. one planner handles both enum modes; +2. adaptive memo state carries the required A and derived B/D ceilings; +3. the common frontier implements per-path preprocessing-first semantics; +4. uniform regressions remain unchanged where policy is unchanged; +5. adaptive selections agree with a bounded unpruned reference traversal; and +6. no planner branch refers to `MixedDimFp128OneHot` by name. + +Simply moving the current module's contents into another file is not +consolidation. + +## Configuration ownership + +### CommitmentConfig surface + +`CommitmentConfig` should project the enum mode and its static dimension domains +into the plain-value planner/runtime policy. + +Configuration remains the single source of truth for: + +```text +setup-generation dimension +ring-dimension schedule mode +number of searched levels +uniform suffix dimension +A/B/D capability domains +A/B/D minimum-rank derivation rules and rank-one early stops +selection objective +decomposition and basis range +SIS identity +challenge and honest-fold policy +chunk policy +recursive-setup policy +generated catalog +``` + +Environment variables must not alter catalog-bound policy during proving or +verification. + +### Removing MixedDimFp128OneHot special-casing + +The planner must dispatch on `RingDimensionScheduleMode`, not on the type name +`MixedDimFp128OneHot`. + +Whether the marker type remains temporarily as a concrete catalog/setup policy +identity is a separate cleanup decision. The requirement is one canonical +implementation, not necessarily immediate deletion of every named zero-sized +policy type. + +### Adapters + +Recursive-setup and multi-chunk adapters must explicitly preserve, narrow, or +reject `AdaptiveDimension`. They must not inherit an adaptive search domain +accidentally when their planner path supports only uniform D64. + +## Generated schedule table storage + +The offline emitter writes generated Rust modules under: + +```text +crates/akita-schedules/src/generated/ +``` + +The bootstrap command is: + +```bash +scripts/generate-schedule-tables.sh +``` + +For the current native fp128 mixed family, the generated files are: + +```text +fp128_mixed_dim_onehot.rs +fp128_mixed_dim_onehot_precommitted.rs +``` + +Large generated `fp*.rs` family files are intentionally ignored by Git and +recreated locally and in CI. The checked-in `generated/mod.rs` supplies +feature-gated wiring and constructs the `GeneratedScheduleTable`. + +Generated rows are compact Rust static data. Runtime expansion reconstructs +widths, SIS keys, and secure ranks through canonical primitives. + +The current `fp128_mixed_dim_onehot` generated family contains only: + +```text +nv = 32 +num_polynomials = 1 +``` + +The complete adaptive search policy—not only the winning dimension path—must +be bound into catalog identity. Generated runtime rows need contain only the +selected schedule. + +## Current benchmark and config mapping + +The repository currently exercises mixed dimensions through distinct paths. + + +| Experiment | Effective config | Schedule source | +| ------------------------------------ | ------------------------------------------------------------------------------------ | ----------------------------------- | +| Stock `onehot_fp128_mixed_dim`, nv32 | `MixedDimFp128OneHot` | Generated runtime catalog | +| Planner diagnostic, nv18–nv40 | Policy derived from `MixedDimFp128OneHot` | Direct offline `find_schedule` call | +| D256 direct timing profile | `MixedDConfig` | Synthetic test-support builder | +| D256 three-band timing profile | `ThreeBandRingDimensionTransitionConfig` | Synthetic test-support builder | + + +### Native generated adaptive benchmark + +The stock mode: + +```text +AKITA_MODE=onehot_fp128_mixed_dim +``` + +uses `fp128::MixedDimFp128OneHot`, fixes nv32, calls +`Cfg::runtime_schedule`, and gives that exact generated row to the PCS prover +and verifier. + +### Direct offline diagnostics + +The `mixed_dimension_search` example derives policy from +`MixedDimFp128OneHot` but calls the offline planner directly. The nv18, nv24, +nv32, nv36, and diagnostic over-cap nv40 results discussed in this design +review came from this path and are not current runtime catalog rows. + +### Synthetic D256 profiles + +The measured D256 direct and three-band schedules currently use test-support +config adapters. They do not use the native mixed generated table. + +Under this proposal, a two-level bounded A search includes these A paths: + +```text +256 -> 64 +256 -> 128 +256 -> 256 +``` + +After deterministic B/D selection and uniform-D64 suffix planning, the +rank/dimension rule may select any of these paths. For current `nv=36`, the +representatives have L1 A ranks 5, 3, and 2 respectively, so `256 -> 256` +wins. Once generated-catalog coverage and equivalent protocol tests exist, the +synthetic adapters may be removed. + +## Catalog and runtime boundary + +Adaptive search remains offline: + +```text +CommitmentConfig + -> RingDimensionScheduleMode + -> bounded A search and deterministic B/D derivation + -> selected generated row +``` + +Runtime proving and verification perform only: + +```text +validate catalog identity +look up the exact workload key +expand the frozen selected row +reject a missing row +``` + +Runtime must not rerun A search or select B/D based on locally observed ranks. + +Catalog identity must bind: + +- enum mode and stable variant identity; +- setup-generation dimension; +- number of searched levels; +- uniform suffix dimension; +- ordered A/B/D dimension capability domains; +- non-increasing A and B/D monotonic ceiling rules; +- deterministic B/D minimum-rank selection, smaller-dimension tie-break, and +rank-one early-stop semantics; +- deterministic A rank/dimension path selection, non-rank-one fallback, and + rank-one early-stop semantics; +- preprocessing/proof/descriptor representative selection inside each exact A + path; +- SIS modulus profile, security policy, and table digest; +- challenge coverage over the complete A domain; +- honest-fold sizing identity; +- decomposition and basis range; +- chunk policy; and +- recursive-setup policy. + +Changing any of these invalidates the catalog even when current winning rows do +not change. + +## Implementation sequence + +This section describes a possible future sequence; it does not authorize code +changes. + +### Cut 1: policy and identity + +1. Add `UniformDimension` and `AdaptiveDimension`. +2. Add search-level, suffix, and role capability fields. +3. Define and bind the deterministic B/D minimum-rank rule and rank-one early + stop. +4. Define and bind A path representative selection followed by per-level + rank/dimension selection and non-rank-one fallback. +5. Extend catalog identity with every new semantic input. +6. Express existing uniform configs through `UniformDimension`. + +### Cut 2: bounded adaptive engine + +1. Enumerate non-increasing A paths only inside the configured window. +2. Derive B/D without branching. +3. Preserve exact setup/proof frontiers inside each A path. +4. Hand the exact boundary witness to the uniform suffix planner. +5. Select each path representative by preprocessing fields, proof bytes, and + descriptor bytes, then select the A path by per-level rank and dimension. + +### Cut 3: D256 generated coverage + +1. Add workloads that exercise A paths `256 -> 64`, `256 -> 128`, and + `256 -> 256`. +2. Pin derived D256 role topologies where current SIS data supports them. +3. Compare generated/runtime replay with current synthetic protocol coverage. +4. Remove synthetic adapters only after coverage is equivalent. + +### Cut 4: planner consolidation + +1. Generalize the common schedule state over the enum mode. +2. Remove config-name dispatch. +3. Delete `mixed_search.rs` when its state/frontier behavior is fully owned by + the common engine. + +### Cut 5: optional D512 admission + +1. Resolve D512 setup generation. +2. Resolve dimension-dependent honest-fold sizing. +3. Validate D512 A-role search with D128/D64 B/D derivation. +4. Regenerate catalogs under the new identity. + +## Required tests + + +| Area | Required property | +| ------------------------- | --------------------------------------------------------------------------------------------------------------- | +| Enum validation | Uniform and adaptive modes reject malformed policy data | +| Uniform preservation | Equivalent `UniformDimension` policies preserve existing descriptors and estimates | +| Search boundary | A is enumerated only at levels `< num_search_levels` | +| Non-increasing A | Smaller and equal A transitions are accepted; increasing A transitions inside the search window are rejected | +| Suffix boundary | Level `num_search_levels` and later, including terminal, are uniform at the configured suffix dimension | +| A enumeration | Every supported non-increasing A path in the bounded domain is considered | +| Per-path representative | Each exact A path first selects its best complete setup/proof/descriptor geometry | +| A rank scan | Path representatives minimize A rank at each searched level; rank one stops dimension growth | +| A rank tie | Equal A ranks prefer the smaller A dimension | +| A non-rank-one fallback | If no allowed A dimension reaches rank one, the smallest secure rank remains valid | +| No B/D branching | Each A/geometry candidate produces at most one derived B and one derived D choice | +| B rank scan | B dimensions are tried in ascending order, the lowest exact secure rank wins, and rank one stops the scan early | +| D rank scan | D dimensions are tried in ascending order, the lowest exact secure rank wins, and rank one stops the scan early | +| B/D rank tie | Equal secure ranks select the smaller role dimension | +| B/D non-rank-one fallback | If no dimension reaches rank one, the lowest-rank supported B/D matrix remains valid | +| B/D infeasibility | An A/geometry candidate is infeasible only when a role has no admissible SIS-supported dimension | +| Role monotonicity | Derived B/D dimensions do not increase across searched levels | +| A rank | A candidates with rank greater than one remain eligible only when no allowed dimension lowers that rank | +| D256 direct | The two-level search can derive `256/128/128 -> 64/64/64 -> D64` | +| D256 three-band | The two-level search can derive `256/128/128 -> 128/64/64 -> D64` from exact boundary witnesses | +| Objective | A rank/dimension paths win first; setup, proof, and descriptor select the representative within each path | +| Setup tie | Equal preprocessing sizes within one A path compare proof bytes, then descriptor bytes | +| Frontier | Parent-masked child setup differences retain the correct lower-proof alternative | +| Setup cap | Over-capacity candidates do not exclude valid siblings | +| D512 setup | D512 A candidates reject under D256 setup generation | +| D512 roles | D512 is never inferred for unsupported B/D roles | +| Catalog drift | Changing domains, search depth, suffix, B/D rule, or objective invalidates catalogs | +| Runtime boundary | Missing rows reject without planner fallback | +| Adapter policy | Recursive and multi-chunk adapters explicitly preserve, narrow, or reject adaptive mode | + + +## Acceptance criteria + +The first implementation is complete when: + +1. `RingDimensionScheduleMode` exposes `UniformDimension` and + `AdaptiveDimension`. +2. `AdaptiveDimension` carries a bounded leading search depth, uniform suffix, + and separate A/B/D capability domains. +3. Only A dimensions produce search branches. +4. A is smaller than or equal to its preceding dimension between adjacent + searched levels. +5. A search stops at the configured boundary. +6. B and D are independently derived by ascending dimension scans that minimize + exact secure rank, stop early at rank one, and prefer smaller dimensions on + rank ties. +7. A uses the smallest secure rank available at each searched level, prefers + the smaller dimension on a rank tie, and remains valid above rank one when + the domain cannot reduce it further. +8. Each exact A-dimension path first selects its best complete schedule by + preprocessing fields, proof bytes, and descriptor bytes; path + representatives are then selected by their per-level A rank/dimension vector. +9. A two-level search includes both D256 paths: + ```text + 256/128/128 -> 64/64/64 -> D64 + 256/128/128 -> 128/64/64 -> D64 + ``` +10. Planner logic contains no branch keyed on `MixedDimFp128OneHot`. +11. Runtime remains generated-catalog-only. + +## Remaining implementation questions + +The main policy direction is resolved. These implementation-level questions +remain: + +1. Should invalid dimensions be rejected when constructing the policy, or + filtered as unsupported capabilities before catalog identity is computed? +2. Should `num_search_levels` be capped by a small protocol constant to bound + adversarial custom policies in offline tools? +3. Should basis and block-split enumeration remain exhaustive at every searched + A level or use the current canonical suffix split heuristic at later levels? +4. Which config type initially owns the adaptive policy after planner + special-casing is removed? +5. Which adapters narrow adaptive mode to uniform D64? +6. What honest-fold API is required before D512 enters the active A domain? diff --git a/specs/mixed-ring-dimension-per-level.md b/specs/mixed-ring-dimension-per-level.md index bdca1868f..ebff98624 100644 --- a/specs/mixed-ring-dimension-per-level.md +++ b/specs/mixed-ring-dimension-per-level.md @@ -52,18 +52,20 @@ recursive setup offload remain outside the mixed search. The older transition profiles in this document are synthetic schedules built in `akita-pcs` test support and are labeled as such. -The proposed next step is to make dimension choice part of the offline planner. -The requested selection order is: +Dimension choice is part of the offline planner. The selection order is: ```text -1. smallest physical setup matrix, measured in base-field elements; -2. smallest exact modeled proof payload; -3. deterministic canonical tie-break only. +1. within each exact A-dimension path, select the smallest physical setup, + then proof payload, then descriptor; +2. compare path representatives by (A rank, A dimension) at each searched + level; +3. stop dimension growth at rank one, or retain the smallest available rank + when rank one is unavailable. ``` This policy is implemented by the offline direct scalar entry point and bound to the generated mixed catalog as -`MinSetupMatrixFieldElementsThenProofPayload`. Prover and verifier remain +`MinAdaptiveARankDimensionThenSetupAndProof`. Prover and verifier remain catalog-only and never run the planner. The currently preferred measured design remains: @@ -294,8 +296,9 @@ 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. +That is sufficient for the two original scalar-D policies. It is not +sufficient for per-A-path setup/proof representative selection followed by +rank-first mixed-D path selection. ### Current mixed-D gap @@ -545,7 +548,8 @@ The approved mixed search is deliberately bounded: survive until the root descriptor comparator chooses a canonical winner. 6. Do not terminate before L2: the terminal and every fold from L2 onward use D64. -7. At the root, choose the global minimum by the requested score. +7. At the root, select the setup/proof-optimal representative for each exact A + path, then choose by the per-level `(A rank, A dimension)` vector. `derive_candidate_level_params_all_splits` is required only at the two mixed levels. Once the schedule returns to D64, `derive_candidate_level_params` @@ -561,17 +565,18 @@ The suffix context must resolve the A-role ring challenge per candidate become dynamic, the memo key must carry the complete incoming prefix identity, including `d_setup`, not only its natural length. -### Selection policy and the current nv=36 data +### Selection policy and the historical nv=36 data -Add a new catalog-bound selection policy with semantics equivalent to: +The adaptive catalog uses the catalog-bound policy: ```text -MinSetupMatrixFieldElementsThenProofPayload +MinAdaptiveARankDimensionThenSetupAndProof ``` -Do not change the meaning of `MinEstimatedProofPayload` in place. Existing -uniform catalogs may continue to use the old ID until intentionally -regenerated; adaptive mixed-D catalogs use the new ID. +For each exact A-dimension path, setup fields, proof bytes, and descriptor bytes +select the representative. Representatives are then compared by their +per-level `(A rank, A dimension)` vectors. Existing uniform catalogs retain +`MinEstimatedProofPayload`. The current benchmark makes the requested policy's result concrete: @@ -583,12 +588,12 @@ The current benchmark makes the requested policy's result concrete: | E | **67,633,152** | 95,768 | **21.869 ms** | | F | 90,177,536 | 98,229 | 27.153 ms | -Under an unrestricted choice among only these five predefined schedules, -`(setup field elements, proof bytes)` selects A′: it ties B/E on setup and -has the smallest proof among them. That historical comparison is not a correctness reference -for the approved planner domain. The planner additionally enforces -component-wise descent and returns to D64 at L2. It also searches block splits -that do not necessarily reproduce any predefined profile. +Under the superseded setup/proof-only comparison among these five predefined +schedules, A′ ties B/E on setup and has the smallest proof among them. That +historical comparison is not a correctness reference for the implemented +rank-first planner domain. The planner additionally enforces component-wise +non-increase, returns to D64 at L2, and searches block splits that do not +necessarily reproduce any predefined profile. This also proves that setup footprint alone is not a complete verifier-time model: B and E verify about 21% faster than A′ despite the same setup @@ -601,8 +606,7 @@ selection policy such as: ``` Do not infer timing weights from one machine or quietly add fold count as a -hidden objective. The first implementation should follow the requested -two-component policy unless this decision is changed before coding. +hidden objective. ### Recursive setup and multi-chunk policy @@ -616,7 +620,7 @@ and the production planner/catalog restricts setup-prefix commitments to D64. The synthetic experiment below proves that the protocol can consume a D128 prefix source with a D64 outer commitment, but it does not change that planner policy. Recursive setup selection is a distinct semantic policy, not a special -case of setup-envelope-first selection. +case of adaptive A-path rank selection. Initial planner-native mixed-D work should: @@ -729,11 +733,13 @@ catalog/policy digest, and effective schedule digest. 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 +- require every adaptive A/B/D capability list in + `PlannerPolicy::ring_dimension_schedule_mode` to be strictly sorted, + duplicate-free, and non-empty so each 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; +- reject role dimensions that are not divisors of the setup-generation + dimension, cannot descend to the uniform suffix, or violate A-carrier + projection at candidate construction; - enumerate bases, dimensions, and splits in a documented order; - store frontiers in ordered collections or sort before selection/emission; - compare semantic cost components first; @@ -776,11 +782,12 @@ byte-identical. 3. Enumerate all admitted tuples and block splits at L0 and L1. 4. Enforce component-wise non-increasing transitions and a uniform-D64 L2+ suffix. -5. Retain the unpruned L0/L1 frontier; do not apply rank-one dimension caps - until an equivalence key is proved against the unpruned reference traversal. +5. Retain the unpruned L0/L1 frontier and select one setup/proof-optimal + representative for every A-dimension path. 6. Retain edge-safe setup/proof frontiers across the mixed boundary, then reuse the existing uniform-D64 split search. -7. Select by setup field elements, then proof bytes, then descriptor bytes. +7. Select path representatives by per-level A rank and dimension, with setup, + proof bytes, and descriptor bytes already minimized inside each path. 8. Keep recursive setup families on singleton D64. #### Cut 2: catalog replay and shipped adaptive family (implemented for fp128 one-hot) @@ -803,25 +810,25 @@ byte-identical. ### Implementation checkpoint and planner example -The current branch implements the first offline direct scalar cut while -preserving all generated catalogs: +The current branch implements the declarative offline direct scalar planner: -- `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; +- `PlannerPolicy::ring_dimension_schedule_mode` is the one catalog-bound + source of uniform/adaptive behavior and the ordered A/B/D capability lists; +- the one canonical `find_schedule` entry point dispatches from that enum: + `UniformDimension` preserves the uniform objective, while + `AdaptiveDimension` first selects the setup/proof-optimal representative for + each A path and then minimizes per-level A rank and dimension; - 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; +- L0 and L1 exhaustively enumerate splits and non-increasing A choices; B and D + are derived without branching by minimum secure rank and smaller-dimension + tie-breaking; - 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; +- rank one stops A/B/D dimension growth, but the smallest available rank above + one remains valid when no larger allowed dimension improves it; +- a test-only unpruned traversal checks the production frontier and canonical + selection while sharing canonical candidate construction and pricing + primitives; - hand-calculated regressions independently pin exact field-element setup rounding, candidate-local EOR pricing, unsupported SIS-cell skipping, and complete-schedule descriptor ties; @@ -833,51 +840,13 @@ preserving all generated catalogs: to use the existing grouped planner. `crates/akita-planner/examples/mixed_dimension_search.rs` exercises both the -implemented and preserved paths. With setup generation D256, `nv=18`, and: - -```text -64/64/64 -128/64/64 -128/128/128 -256/128/128 -``` - -the constrained mixed search now selects: - -```text -L0: 128/64/64, ranks 2/1/1, input 262,144, output 225,152 -L1: 128/64/64, ranks 2/1/1, input 225,152, output 138,752 -L2: 64/64/64, ranks 4/1/1, input 138,752, output 105,984 -terminal: D64, rank 4, input 105,984 -``` - -Its selected score is 88,064 physical setup field elements and 77,320 modeled -proof bytes. - -Release-process measurements after the bounded-search change were: - -| `nv` | Observed wall time | L0 | L1 | L2+ | Physical setup fields | Proof bytes | -|---:|---:|---|---|---|---:|---:| -| 18 | 0.16 s | `128/64/64` | `128/64/64` | D64 | 88,064 | 77,320 | -| 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. - -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. +implemented and preserved paths. The current result table is maintained in +the benchmark-status section below. The important selection regression is +`nv=36`: the best representatives for L1 D64, D128, and D256 have A ranks 5, +3, and 2, so the planner selects D256/rank 2 even though rank one is not +available. The search still exhausts splits and basis choices inside each +dimension path before comparing ranks, preventing a worse geometry from +winning solely because it happens to lower rank. For the PR recursive multi-group shape, the new entry point returns the expected unsupported-policy error because mixed recursive setup is a later @@ -1367,6 +1336,62 @@ per-matrix coverage is `per_matrix_ring_dims_root_e2e.rs`. ## Benchmark status +### Declarative adaptive-planner rerun + +The enum-driven planner was rerun on 2026-08-05 after adding rank-first A-path +selection. These are offline planner outputs. `Modeled proof bytes` is the +planner's conservative payload estimate, not the data-dependent serialized +proof length reported by the end-to-end profiler. + +| `nv` | Selected L0 | L0 ranks | Selected L1 | L1 ranks | L2+ | Levels including terminal | Physical setup fields | Modeled proof bytes | +|---:|---|---|---|---|---|---:|---:|---:| +| 18 | `256/64/64` | `1/1/1` | `256/64/64` | `1/1/1` | uniform D64 | 4 | 163,840 | 82,440 | +| 24 | `256/64/64` | `1/1/1` | `256/64/64` | `1/1/1` | uniform D64 | 6 | 524,288 | 89,840 | +| 32 | `256/64/64` | `1/1/1` | `256/64/64` | `2/1/1` | uniform D64 | 8 | 8,388,608 | 97,432 | +| 36 | `256/128/128` | `1/1/1` | `256/64/64` | `2/1/1` | uniform D64 | 8 | 45,088,768 | 99,512 | +| 40 diagnostic | `256/128/128` | `2/1/1` | `256/64/64` | `2/1/1` | uniform D64 | 8 | 268,435,456 | 101,192 | + +For `nv=36`, the setup/proof-optimal representatives for L1 A dimensions D64, +D128, and D256 have ranks 5, 3, and 2. No allowed dimension reaches rank one, +so the smallest-rank fallback selects D256/rank 2. B and D independently reach +rank one at D64, producing the selected `256/64/64` L1 tuple. + +The `nv=40` diagnostic confirms the same fallback at a larger workload: D256 +requires rank two at both L0 and L1 and is still selected because it is the +smallest rank in the configured domain. The normal preset rejects `nv=40` +because its 268,435,456-field preprocessing requirement exceeds the current +67,108,864-field cap; the row was obtained by lifting only that cap in an +offline diagnostic. + +The previously measured `nv=36` timing below belongs to the superseded +setup/proof-first winner, not the rank-first schedule now selected: + +| Superseded schedule | Commit | Prove | Verify | Actual proof bytes | Fold / terminal bytes | Levels | +|---|---:|---:|---:|---:|---:|---:| +| `256/128/128 → 64/64/64 → D64` | 8.488 s | 2.669 s | 16.926 ms | 93,959 | 36,256 / 57,703 | 8 | + +The new `256/128/128 → 256/64/64 → D64` winner was measured on 2026-08-05 on +the same Apple M4 Max host and with the same thread and warmup protocol as the +current-main table below. The build used `--no-default-features` with +`parallel,profile-ci`; setup contributions were direct and tracing was off. +The profiler's oversized public-opening weight table was factorized before the +timed phases for this diagnostic, without changing commit, prove, verify, or +serialization. The diagnostic wiring was removed afterward. + +| Rank-first schedule | Retained run | Commit | Prove | Verify | Actual proof bytes | Fold / terminal bytes | Levels | +|---|---:|---:|---:|---:|---:|---:|---:| +| `256/128/128 → 256/64/64 → D64` | 1 | 8.830 s | 2.622 s | 19.179 ms | 94,721 | 37,040 / 57,681 | 8 | +| `256/128/128 → 256/64/64 → D64` | 2 | 8.369 s | 2.605 s | 18.882 ms | 94,721 | 37,040 / 57,681 | 8 | +| **Two-run mean** | — | **8.599 s** | **2.613 s** | **19.031 ms** | **94,721** | **37,040 / 57,681** | **8** | + +Relative to the superseded row, rank-first L1 D256 makes commit 1.3% slower, +prove 2.1% faster, and verify 12.4% slower in these two-run means. It adds 762 +serialized bytes: 784 bytes in the fold transcript, offset by a 22-byte smaller +terminal response. The actual proof remains 4,791 bytes below the planner's +99,512-byte conservative estimate. The previous native `nv=32` measurement +also predates rank-first selection and must not be attributed to the regenerated +row. + ### Current-main rerun with D256 topologies The table below was measured on 2026-08-05 from `30e69d4d4d` on the same Apple diff --git a/specs/recursive-mixed-ring-dimension-performance.md b/specs/recursive-mixed-ring-dimension-performance.md index 5f5bdddc4..c8aa1f4bd 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 From dfff6a8f4b499b62eaa9b177b56cecb28f0d9485 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Thu, 6 Aug 2026 07:44:44 -0700 Subject: [PATCH 03/24] fix(schedules): align generated catalog after main merge --- crates/akita-config/tests/generated_tables.rs | 35 ++-- crates/akita-schedules/src/generated/mod.rs | 153 +++++++++--------- 2 files changed, 92 insertions(+), 96 deletions(-) diff --git a/crates/akita-config/tests/generated_tables.rs b/crates/akita-config/tests/generated_tables.rs index ab8681580..bcb857fc3 100644 --- a/crates/akita-config/tests/generated_tables.rs +++ b/crates/akita-config/tests/generated_tables.rs @@ -279,8 +279,20 @@ fn equal_lookup_keys_form_one_contiguous_candidate_range() { #[cfg(feature = "all-schedules")] #[test] -fn mixed_catalog_identity_binds_nonwinning_a_dimensions() { - static WITHOUT_NONWINNER: &[usize] = &[64, 256]; +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"); @@ -293,24 +305,7 @@ fn mixed_catalog_identity_binds_nonwinning_a_dimensions() { != 128)); let mut mutated = 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, - }; + mutated.identity.ring_dimension_candidates = WITHOUT_NONWINNER; let error = validate_catalog_identity( &mutated, &policy, diff --git a/crates/akita-schedules/src/generated/mod.rs b/crates/akita-schedules/src/generated/mod.rs index c840043cc..786b521cd 100644 --- a/crates/akita-schedules/src/generated/mod.rs +++ b/crates/akita-schedules/src/generated/mod.rs @@ -160,8 +160,9 @@ pub struct GeneratedScheduleCatalogIdentity { pub recursive_setup_planning: bool, pub root_fold_shape: akita_challenges::TensorChallengeShape, - /// Complete uniform or adaptive dimension policy used to generate this catalog. - pub ring_dimension_schedule_mode: crate::RingDimensionScheduleMode, + /// 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], pub ring_dimensions: &'static [usize], pub ring_challenge_config_digest: u64, pub key_count: usize, @@ -180,7 +181,7 @@ pub mod validate; pub(crate) mod walk; pub use crate::{ ChunkedWitnessCfg, CommitmentRingDims, DecompositionParams, PlannerCostModelId, - RingDimensionScheduleMode, SelectionPolicyId, SisSecurityPolicyId, TensorChallengeShape, + SelectionPolicyId, SisSecurityPolicyId, TensorChallengeShape, }; pub use akita_types::{ CommitmentPayloadMode, CommittedGroupProfile, InnerCommitMatrixParams, OuterCommitMatrixParams, @@ -342,6 +343,79 @@ fn precommitted_group_key_eq( generated == layout } +#[cfg(test)] +mod mixed_dimension_key_tests { + use super::{precommitted_group_key_eq, precommitted_group_sort_key}; + use akita_types::{ + CommittedGroupProfile, InnerCommitMatrixParams, OuterCommitMatrixParams, + PolynomialGroupLayout, SisModulusProfileId, SisTableDigest, + }; + + fn descriptor() -> CommittedGroupProfile { + CommittedGroupProfile { + version: CommittedGroupProfile::VERSION, + group: PolynomialGroupLayout::new(12, 1), + num_live_ring_elements_per_claim: 32, + num_positions_per_block: 8, + num_live_blocks: 4, + log_basis_inner: 4, + num_digits_inner: 2, + inner_commit_matrix: InnerCommitMatrixParams::new_unchecked( + akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, + SisTableDigest::CURRENT, + SisModulusProfileId::Q128OffsetA7F7, + 3, + 16, + 7, + 128, + ), + log_basis_outer: 5, + num_digits_outer: 2, + outer_commit_matrix: OuterCommitMatrixParams::new_unchecked( + akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, + SisTableDigest::CURRENT, + SisModulusProfileId::Q128OffsetA7F7, + 2, + 48, + 11, + 64, + ), + } + } + + #[test] + fn precommitted_key_identity_includes_both_native_ring_dimensions() { + let base = descriptor(); + let mut changed_inner = base; + changed_inner.inner_commit_matrix = InnerCommitMatrixParams::new_unchecked( + akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, + SisTableDigest::CURRENT, + SisModulusProfileId::Q128OffsetA7F7, + 3, + 16, + 7, + 64, + ); + let mut changed_outer = base; + changed_outer.outer_commit_matrix = OuterCommitMatrixParams::new_unchecked( + akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, + SisTableDigest::CURRENT, + SisModulusProfileId::Q128OffsetA7F7, + 2, + 48, + 11, + 32, + ); + for changed in [changed_inner, changed_outer] { + assert!(!precommitted_group_key_eq(&base, &changed)); + assert_ne!( + precommitted_group_sort_key(&base), + precommitted_group_sort_key(&changed) + ); + } + } +} + /// Returns an error when the generated key does not match the runtime key. pub(crate) fn validate_entry_key( generated: &GeneratedFoldScheduleEntry, @@ -629,76 +703,3 @@ pub fn fp64_d256_onehot_table() -> GeneratedScheduleTable { } } // @generated schedule module wiring end - -#[cfg(test)] -mod mixed_dimension_key_tests { - use super::{precommitted_group_key_eq, precommitted_group_sort_key}; - use akita_types::{ - CommittedGroupProfile, InnerCommitMatrixParams, OuterCommitMatrixParams, - PolynomialGroupLayout, SisModulusProfileId, SisTableDigest, - }; - - fn descriptor() -> CommittedGroupProfile { - CommittedGroupProfile { - version: CommittedGroupProfile::VERSION, - group: PolynomialGroupLayout::new(12, 1), - num_live_ring_elements_per_claim: 32, - num_positions_per_block: 8, - num_live_blocks: 4, - log_basis_inner: 4, - num_digits_inner: 2, - inner_commit_matrix: InnerCommitMatrixParams::new_unchecked( - akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, - SisTableDigest::CURRENT, - SisModulusProfileId::Q128OffsetA7F7, - 3, - 16, - 7, - 128, - ), - log_basis_outer: 5, - num_digits_outer: 2, - outer_commit_matrix: OuterCommitMatrixParams::new_unchecked( - akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, - SisTableDigest::CURRENT, - SisModulusProfileId::Q128OffsetA7F7, - 2, - 48, - 11, - 64, - ), - } - } - - #[test] - fn precommitted_key_identity_includes_both_native_ring_dimensions() { - let base = descriptor(); - let mut changed_inner = base; - changed_inner.inner_commit_matrix = InnerCommitMatrixParams::new_unchecked( - akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, - SisTableDigest::CURRENT, - SisModulusProfileId::Q128OffsetA7F7, - 3, - 16, - 7, - 64, - ); - let mut changed_outer = base; - changed_outer.outer_commit_matrix = OuterCommitMatrixParams::new_unchecked( - akita_types::sis::DEFAULT_SIS_SECURITY_POLICY, - SisTableDigest::CURRENT, - SisModulusProfileId::Q128OffsetA7F7, - 2, - 48, - 11, - 32, - ); - for changed in [changed_inner, changed_outer] { - assert!(!precommitted_group_key_eq(&base, &changed)); - assert_ne!( - precommitted_group_sort_key(&base), - precommitted_group_sort_key(&changed) - ); - } - } -} From 8c76d7ac196d95e5c49b7b8b8297f7596de09269 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Thu, 6 Aug 2026 10:46:43 -0700 Subject: [PATCH 04/24] feat(planner): restore adaptive ring dimension search --- crates/akita-config/src/lib.rs | 25 ++- .../src/precommitted_commitment.rs | 10 +- crates/akita-config/src/proof_optimized.rs | 31 ++-- .../akita-config/src/proof_optimized/fp128.rs | 28 ++- .../akita-config/src/recursive_commitment.rs | 7 +- crates/akita-config/tests/generated_tables.rs | 35 ++-- crates/akita-config/tests/runtime_fallback.rs | 10 +- crates/akita-pcs/examples/profile/modes.rs | 5 +- crates/akita-pcs/examples/profile/workload.rs | 42 ++++- crates/akita-planner/src/emit/mod.rs | 57 ++++-- .../akita-planner/src/generated_families.rs | 6 +- crates/akita-planner/src/lib.rs | 9 +- crates/akita-planner/src/planner.rs | 84 +++------ crates/akita-planner/src/schedule_params.rs | 162 +++++++++++------ .../src/schedule_params/candidate.rs | 2 +- .../schedule_params/candidate/recursive.rs | 46 +++-- .../src/schedule_params/mixed_search.rs | 96 +++++++--- .../src/schedule_params/objective.rs | 2 +- .../src/schedule_params/suffix_dp.rs | 4 +- .../akita-planner/src/test/schedule_params.rs | 86 +++++---- .../akita-planner/src/test/unpruned_search.rs | 12 +- crates/akita-schedules/src/candidate.rs | 109 ++++++++++- .../akita-schedules/src/catalog_identity.rs | 170 ++++++++++++------ .../akita-schedules/src/generated/expand.rs | 14 +- .../src/generated/fp128_d128_dense.rs | 8 +- .../src/generated/fp128_d128_onehot.rs | 8 +- .../src/generated/fp128_d256_onehot.rs | 8 +- .../src/generated/fp128_d64_dense.rs | 8 +- .../generated/fp128_d64_dense_multi_chunk.rs | 8 +- .../src/generated/fp128_d64_onehot.rs | 8 +- .../generated/fp128_d64_onehot_multi_chunk.rs | 8 +- .../fp128_d64_onehot_multi_chunk_w2r2.rs | 8 +- .../fp128_d64_onehot_multi_chunk_w4r2.rs | 8 +- .../generated/fp128_d64_onehot_recursive.rs | 8 +- ...8_d64_onehot_recursive_multi_chunk_w8r2.rs | 8 +- .../src/generated/fp128_d64_onehot_tensor.rs | 8 +- .../src/generated/fp128_mixed_dim_onehot.rs | 50 ++++-- .../src/generated/fp32_d128_onehot.rs | 8 +- .../src/generated/fp32_d256_onehot.rs | 8 +- .../src/generated/fp64_d128_dense.rs | 8 +- .../src/generated/fp64_d128_onehot.rs | 8 +- .../src/generated/fp64_d256_onehot.rs | 8 +- crates/akita-schedules/src/generated/mod.rs | 7 +- crates/akita-schedules/src/lib.rs | 8 +- crates/akita-schedules/src/runtime.rs | 167 +++++++++++++---- 45 files changed, 901 insertions(+), 519 deletions(-) diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index 88c4d2bcb..0fd0bf624 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -10,15 +10,15 @@ use akita_challenges::{SparseChallengeConfig, TensorChallengeShape}; 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::{ - AkitaScheduleInputs, AkitaScheduleLookupKey, ChunkedWitnessCfg, CommitmentRingDims, - CommittedGroupParams, DecompositionParams, FoldSchedule, OpeningClaimsLayout, - SetupMatrixCapacity, SisModulusProfileId, + AkitaScheduleInputs, AkitaScheduleLookupKey, ChunkedWitnessCfg, CommittedGroupParams, + DecompositionParams, FoldSchedule, OpeningClaimsLayout, SetupMatrixCapacity, + SisModulusProfileId, }; /// Define a multi-chunk companion preset that delegates every layout-affecting @@ -35,8 +35,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 { @@ -137,7 +137,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, @@ -205,12 +205,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; diff --git a/crates/akita-config/src/precommitted_commitment.rs b/crates/akita-config/src/precommitted_commitment.rs index acec4a733..ecfe5a2f2 100644 --- a/crates/akita-config/src/precommitted_commitment.rs +++ b/crates/akita-config/src/precommitted_commitment.rs @@ -10,10 +10,9 @@ use crate::{policy_of, CommitmentConfig}; use akita_challenges::{SparseChallengeConfig, TensorChallengeShape}; use akita_field::AkitaError; use akita_types::{ - accumulate_matrix_field_elements_for_level, AkitaScheduleInputs, CommitmentRingDims, - CommittedGroupParams, CommittedGroupProfile, DecompositionParams, FoldSchedule, - OpenCommitMatrixParams, OpeningClaimsLayout, PolynomialGroupLayout, SetupMatrixCapacity, - SisModulusProfileId, + accumulate_matrix_field_elements_for_level, AkitaScheduleInputs, CommittedGroupParams, + CommittedGroupProfile, DecompositionParams, FoldSchedule, OpenCommitMatrixParams, + OpeningClaimsLayout, PolynomialGroupLayout, SetupMatrixCapacity, SisModulusProfileId, }; use std::marker::PhantomData; @@ -27,7 +26,8 @@ impl CommitmentConfig for PrecommittedCommitmentConfig DecompositionParams { Cfg::decomposition() diff --git a/crates/akita-config/src/proof_optimized.rs b/crates/akita-config/src/proof_optimized.rs index 12e8adfbe..8f6cc53a5 100644 --- a/crates/akita-config/src/proof_optimized.rs +++ b/crates/akita-config/src/proof_optimized.rs @@ -405,11 +405,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 +429,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 +442,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 +454,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 806d5b7cc..9d38722bb 100644 --- a/crates/akita-config/src/proof_optimized/fp128.rs +++ b/crates/akita-config/src/proof_optimized/fp128.rs @@ -40,21 +40,9 @@ pub struct D256OneHot; pub struct MixedDimFp128OneHot; 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, - }, - ]; + 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. @@ -182,9 +170,13 @@ impl_proof_optimized_preset!( "fp128_mixed_dim_onehot", fp128_mixed_dim_onehot_table ), - selection_policy = - akita_schedules::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, - ring_dimension_candidates = &MixedDimFp128OneHot::RING_DIMENSION_CANDIDATES + ring_dimension_schedule_mode = akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels: 2, + uniform_suffix_dimension: 64, + potential_a_dimensions: &MixedDimFp128OneHot::A_RING_DIMENSIONS, + potential_b_dimensions: &MixedDimFp128OneHot::B_RING_DIMENSIONS, + potential_d_dimensions: &MixedDimFp128OneHot::D_RING_DIMENSIONS, + } ); impl_proof_optimized_preset!( D512OneHot, diff --git a/crates/akita-config/src/recursive_commitment.rs b/crates/akita-config/src/recursive_commitment.rs index 6dd1369e8..dab5be1eb 100644 --- a/crates/akita-config/src/recursive_commitment.rs +++ b/crates/akita-config/src/recursive_commitment.rs @@ -4,8 +4,8 @@ use crate::CommitmentConfig; use akita_challenges::{SparseChallengeConfig, TensorChallengeShape}; use akita_field::AkitaError; use akita_types::{ - AkitaScheduleInputs, ChunkedWitnessCfg, CommitmentRingDims, DecompositionParams, FoldSchedule, - OpeningClaimsLayout, SetupMatrixCapacity, SisModulusProfileId, + AkitaScheduleInputs, ChunkedWitnessCfg, DecompositionParams, FoldSchedule, OpeningClaimsLayout, + SetupMatrixCapacity, SisModulusProfileId, }; #[cfg(any( feature = "schedules-fp128-d64-onehot-recursive", @@ -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() diff --git a/crates/akita-config/tests/generated_tables.rs b/crates/akita-config/tests/generated_tables.rs index bcb857fc3..6a1d25603 100644 --- a/crates/akita-config/tests/generated_tables.rs +++ b/crates/akita-config/tests/generated_tables.rs @@ -279,20 +279,8 @@ 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, - }, - ]; +fn mixed_catalog_identity_binds_nonwinning_dimensions() { + static WITHOUT_NONWINNER: &[usize] = &[64, 256]; let policy = policy_of::(); let catalog = fp128::MixedDimFp128OneHot::schedule_catalog().expect("mixed catalog"); @@ -305,7 +293,24 @@ fn mixed_catalog_identity_binds_nonwinning_candidate_tuples() { != 128)); let mut mutated = catalog; - mutated.identity.ring_dimension_candidates = WITHOUT_NONWINNER; + 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, diff --git a/crates/akita-config/tests/runtime_fallback.rs b/crates/akita-config/tests/runtime_fallback.rs index 4f6bc8d89..748b7a79c 100644 --- a/crates/akita-config/tests/runtime_fallback.rs +++ b/crates/akita-config/tests/runtime_fallback.rs @@ -308,12 +308,12 @@ fn recursive_adapter_delegates_scalar_keys_to_the_ordinary_catalog() { fn adapters_forward_mixed_dimension_policy() { type Base = fp128::MixedDimFp128OneHot; 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(), @@ -334,7 +334,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, diff --git a/crates/akita-pcs/examples/profile/modes.rs b/crates/akita-pcs/examples/profile/modes.rs index d58e26ab5..2633ee8f9 100644 --- a/crates/akita-pcs/examples/profile/modes.rs +++ b/crates/akita-pcs/examples/profile/modes.rs @@ -392,7 +392,10 @@ fn run_profile_onehot_fp128_d64(nv: usize, num_polys: usize) { #[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!( + matches!(nv, 32 | 36), + "mixed-dimension profile supports generated nv=32 and nv=36 rows" + ); assert_singleton_mode("onehot_fp128_mixed_dim", num_polys); let schedule = Cfg::runtime_schedule(AkitaScheduleLookupKey::single( diff --git a/crates/akita-pcs/examples/profile/workload.rs b/crates/akita-pcs/examples/profile/workload.rs index 5c1a2ad73..6bde1f7f7 100644 --- a/crates/akita-pcs/examples/profile/workload.rs +++ b/crates/akita-pcs/examples/profile/workload.rs @@ -438,14 +438,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>( diff --git a/crates/akita-planner/src/emit/mod.rs b/crates/akita-planner/src/emit/mod.rs index a5778afc4..565ce28e5 100644 --- a/crates/akita-planner/src/emit/mod.rs +++ b/crates/akita-planner/src/emit/mod.rs @@ -526,19 +526,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() @@ -547,8 +568,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", @@ -573,14 +593,15 @@ fn emit_identity_const(identity: &GeneratedScheduleCatalogIdentity) -> String { " witness_chunk: {witness_chunk},\n", " recursive_setup_planning: {recursive_setup_planning},\n", " root_fold_shape: {root_fold_shape},\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, @@ -731,7 +752,7 @@ pub fn emit_family_module(spec: &EmitSpec) -> Result { GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, \ CommitmentRingDims, PlannerCostModelId, PolynomialGroupLayout, CommittedGroupProfile, \ InnerCommitMatrixParams, OuterCommitMatrixParams, \ - CommitmentPayloadMode, SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, \ + CommitmentPayloadMode, RingDimensionScheduleMode, SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, \ TensorChallengeShape,\n}};" ) .map_err(|e| e.to_string())?; diff --git a/crates/akita-planner/src/generated_families.rs b/crates/akita-planner/src/generated_families.rs index 415c7ad4d..fbd830415 100644 --- a/crates/akita-planner/src/generated_families.rs +++ b/crates/akita-planner/src/generated_families.rs @@ -117,8 +117,10 @@ const FP128_D256_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(16), ]; -const FP128_MIXED_DIM_ONEHOT_KEYS: &[PolynomialGroupLayout] = - &[PolynomialGroupLayout::singleton(32)]; +const FP128_MIXED_DIM_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ + PolynomialGroupLayout::singleton(32), + PolynomialGroupLayout::singleton(36), +]; const FP128_D64_ONEHOT_TENSOR_KEYS: &[PolynomialGroupLayout] = &[PolynomialGroupLayout::singleton(26)]; diff --git a/crates/akita-planner/src/lib.rs b/crates/akita-planner/src/lib.rs index 40ae1d8b1..81f0048fd 100644 --- a/crates/akita-planner/src/lib.rs +++ b/crates/akita-planner/src/lib.rs @@ -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; @@ -39,6 +40,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 c9c7784bc..3f9d2f81c 100644 --- a/crates/akita-planner/src/planner.rs +++ b/crates/akita-planner/src/planner.rs @@ -9,18 +9,17 @@ use akita_types::sis::{ InnerCommitMatrixParams, OpenCommitMatrixParams, OuterCommitMatrixParams, }; use akita_types::{ - AkitaScheduleInputs, AkitaScheduleLookupKey, CommitmentRingDims, CommittedGroupParams, - CommittedGroupProfile, DecompositionParams, OpeningClaimsLayout, PlannedFoldSchedule, - PolynomialGroupLayout, PrecommittedLevelParams, WitnessLayout, + AkitaScheduleInputs, AkitaScheduleLookupKey, CommittedGroupParams, CommittedGroupProfile, + DecompositionParams, OpeningClaimsLayout, PlannedFoldSchedule, PolynomialGroupLayout, + 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, optimize_fold_challenge_shape, select_complete_candidate, validate_policy, - RingChallengeConfigFn, RingDimensionSearchDomain, ScheduleMemo, SuffixCtx, SuffixState, - MIXED_SEARCH_FOLD_LEVELS, MIXED_SEARCH_SUFFIX_RING_DIMENSION, + RingChallengeConfigFn, ScheduleMemo, SuffixCtx, SuffixState, }; use crate::PlannerPolicy; @@ -185,7 +184,7 @@ fn materialize_precommitted_group_for_open_basis( struct MultiGroupRootCandidateCtx<'a> { policy: &'a PlannerPolicy, - dimensions: CommitmentRingDims, + dimensions: RingDimensionCandidate<'a>, ring_challenge_cfg: &'a SparseChallengeConfig, requested_fold_shape: TensorChallengeShape, final_honest_fold_policy: HonestFoldPolicySpec, @@ -266,7 +265,7 @@ 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, requested_fold_shape: TensorChallengeShape, @@ -274,9 +273,9 @@ pub(crate) fn root_level_candidates_for_basis( 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!( @@ -307,7 +306,7 @@ pub(crate) fn root_level_candidates_for_basis( &precommitted_groups, policy, ring_challenge_config, - dimensions.d_d(), + dimensions.inner(), candidate_log_basis, )?; for block_index_bits in (min_block_index_bits..=max_block_index_bits).rev() { @@ -369,7 +368,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 { @@ -450,11 +449,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 { @@ -474,11 +471,9 @@ fn root_final_group_level_params_candidate( 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, d_width)) = dimensions.collision_role_price( policy, akita_types::SisMatrixRole::Open, - d_a, - dimensions.d_d(), d_width, log_basis, ) else { @@ -516,26 +511,25 @@ 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 - { + if policy.recursive_setup_planning { return Err(AkitaError::InvalidSetup( - "mixed-D search requires MinSetupMatrixFieldElementsThenProofPayload".into(), + "mixed-D search does not yet support recursive setup planning".into(), )); } - if policy.recursive_setup_planning { + if policy.selection_policy + != crate::SelectionPolicyId::MinAdaptiveARankDimensionThenSetupAndProof + { return Err(AkitaError::InvalidSetup( - "mixed-D search does not yet support recursive setup planning".into(), + "adaptive search requires MinAdaptiveARankDimensionThenSetupAndProof".into(), )); } if policy.witness_chunk.uses_multi_chunk() { @@ -543,24 +537,6 @@ fn validate_mixed_dimension_schedule_request( "mixed-D search does not yet support direct multi-chunk planning".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(()) } @@ -575,27 +551,19 @@ pub fn find_schedule( ) -> Result { 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)?; + if matches!( + policy.ring_dimension_schedule_mode, + crate::RingDimensionScheduleMode::AdaptiveDimension { .. } + ) { + validate_adaptive_dimension_schedule_request(key, policy)?; return mixed_search::find_schedule( key.final_group, policy, final_honest_fold_policy, - &dimensions, ring_challenge_config, fold_challenge_shape_at_level, ); } - if policy.selection_policy - == crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload - { - return Err(AkitaError::InvalidSetup( - "setup-field mixed selection requires an explicit mixed dimension domain".to_string(), - )); - } let ring_challenge_config: RingChallengeConfigFn<'_> = &ring_challenge_config; let fold_challenge_shape_at_level = &fold_challenge_shape_at_level; let scalar_policy; @@ -654,7 +622,7 @@ pub fn find_schedule( crate::SelectionPolicyId::MinEstimatedProofPayload => { select_complete_candidate(active_policy, suffix.best_by_payload_per_lb.values())? } - crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload => { + crate::SelectionPolicyId::MinAdaptiveARankDimensionThenSetupAndProof => { return Err(AkitaError::UnsupportedSchedule( "mixed ring-dimension selection is not supported for multi-group roots".to_string(), )); diff --git a/crates/akita-planner/src/schedule_params.rs b/crates/akita-planner/src/schedule_params.rs index 8edcfed65..daf621520 100644 --- a/crates/akita-planner/src/schedule_params.rs +++ b/crates/akita-planner/src/schedule_params.rs @@ -37,7 +37,6 @@ mod suffix_dp; #[cfg(test)] #[path = "test/unpruned_search.rs"] mod unpruned_search; - pub use akita_types::suffix_opening_layout; pub(crate) use candidate::{ derive_candidate_level_params, derive_candidate_level_params_all_splits, @@ -48,7 +47,9 @@ pub(crate) use setup_score::{ }; pub(crate) use suffix_dp::{derive_optimal_suffix_schedule, ScheduleMemo, SuffixCtx, SuffixState}; +#[cfg(test)] pub(crate) const MIXED_SEARCH_FOLD_LEVELS: usize = 2; +#[cfg(test)] pub(crate) const MIXED_SEARCH_SUFFIX_RING_DIMENSION: usize = 64; #[derive(Clone, Debug)] @@ -75,16 +76,18 @@ pub(crate) struct CandidateTerminalResponse { /// 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 +105,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(()) + 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)] @@ -158,6 +159,30 @@ impl ScheduleCandidate { self.setup_field_elements, ) } + + pub(crate) fn adaptive_a_rank_dimension_key( + &self, + num_search_levels: usize, + ) -> Vec<(usize, usize)> { + self.folds + .iter() + .take(num_search_levels) + .map(|fold| { + ( + fold.params.inner_commit_matrix.output_rank(), + fold.params.role_dims().d_a(), + ) + }) + .collect() + } + + pub(crate) fn adaptive_a_dimension_key(&self, num_search_levels: usize) -> Vec { + self.folds + .iter() + .take(num_search_levels) + .map(|fold| fold.params.role_dims().d_a()) + .collect() + } } /// Exact Stage-3 payload induced when `successor` consumes the setup prefix @@ -305,6 +330,46 @@ pub(crate) fn candidate_schedule_descriptor_bytes( .canonical_descriptor_bytes()) } +pub(crate) fn select_adaptive_candidate( + candidates: Vec, + num_search_levels: usize, +) -> Result, AkitaError> { + let mut per_path = candidates + .into_iter() + .map(|candidate| { + let descriptor = candidate_schedule_descriptor_bytes(&candidate)?; + Ok(( + candidate.adaptive_a_dimension_key(num_search_levels), + MixedScore { + setup_field_elements: candidate.setup_field_elements, + proof_bytes: candidate.total_bytes, + }, + descriptor, + candidate, + )) + }) + .collect::, AkitaError>>()?; + per_path + .sort_by(|left, right| (&left.0, &left.1, &left.2).cmp(&(&right.0, &right.1, &right.2))); + per_path.dedup_by(|left, right| left.0 == right.0); + let mut winners = per_path + .into_iter() + .map(|(_, score, descriptor, candidate)| { + ( + candidate.adaptive_a_rank_dimension_key(num_search_levels), + score, + descriptor, + candidate, + ) + }) + .collect::>(); + winners.sort_by(|left, right| (&left.0, &left.1, &left.2).cmp(&(&right.0, &right.1, &right.2))); + Ok(winners + .into_iter() + .next() + .map(|(_, _, _, candidate)| candidate)) +} + fn witness_partition(num_chunks: usize) -> WitnessPartition { if num_chunks == 1 { WitnessPartition::Single @@ -324,27 +389,7 @@ fn witness_partition(num_chunks: usize) -> WitnessPartition { /// 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(), - )); - } + akita_schedules::planner_support::validate_policy(policy)?; if policy.setup_field_budget == Some(0) { return Err(AkitaError::InvalidSetup( "explicit setup field budget must be positive".to_string(), @@ -494,12 +539,36 @@ pub fn derive_standalone_precommit_profile( let mut best: Option<(usize, CommittedGroupParams)> = None; let schedule_key = AkitaScheduleLookupKey::single(key); + let dimension_candidates = match direct_policy.ring_dimension_schedule_mode { + crate::RingDimensionScheduleMode::UniformDimension { ring_dimension } => vec![ + akita_schedules::planner_support::RingDimensionCandidate::Fixed( + CommitmentRingDims::uniform(ring_dimension), + ), + ], + crate::RingDimensionScheduleMode::AdaptiveDimension { + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + .. + } => potential_a_dimensions + .iter() + .copied() + .map( + |inner| akita_schedules::planner_support::RingDimensionCandidate::Adaptive { + inner, + outer_dimensions: potential_b_dimensions, + opening_dimensions: potential_d_dimensions, + ceiling: CommitmentRingDims::uniform(direct_policy.uniform_ring_dimension), + }, + ) + .collect(), + }; 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 { + for dimensions in dimension_candidates.iter().copied() { + let Ok(ring_challenge_cfg) = ring_challenge_config(dimensions.inner()) else { continue; }; - let alpha = (dimensions.d_a() as u32).trailing_zeros() as usize; + let alpha = (dimensions.inner() as u32).trailing_zeros() as usize; let reduced_vars = key.num_vars().saturating_sub(alpha); if reduced_vars == 0 { continue; @@ -540,15 +609,6 @@ pub fn derive_standalone_precommit_profile( // 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..0ec2e2dc7 100644 --- a/crates/akita-planner/src/schedule_params/candidate.rs +++ b/crates/akita-planner/src/schedule_params/candidate.rs @@ -1,6 +1,6 @@ use super::*; -use akita_schedules::planner_support::{projected_collision_role_price, sis_key_at_dimension}; +use akita_schedules::planner_support::{sis_key_at_dimension, RingDimensionCandidate}; mod recursive; mod setup_prefix; diff --git a/crates/akita-planner/src/schedule_params/candidate/recursive.rs b/crates/akita-planner/src/schedule_params/candidate/recursive.rs index b4d7c9b67..51172392e 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, @@ -44,18 +44,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, @@ -70,7 +71,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, fold_challenge_shape, @@ -80,12 +81,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); @@ -98,11 +94,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 { @@ -116,11 +110,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 { @@ -279,7 +271,7 @@ 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, @@ -287,7 +279,8 @@ fn prepare_recursive_level_search( requested_fold_shape: TensorChallengeShape, ) -> 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); } @@ -295,7 +288,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()))? @@ -320,7 +313,10 @@ fn prepare_recursive_level_search( log_basis, n_prefix, num_chunks, - dimensions.d_b(), + match dimensions { + RingDimensionCandidate::Fixed(value) => value.d_b(), + RingDimensionCandidate::Adaptive { .. } => d_a, + }, )? else { return Ok(None); @@ -342,7 +338,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, @@ -404,7 +400,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, @@ -457,7 +453,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, @@ -509,7 +505,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/mixed_search.rs b/crates/akita-planner/src/schedule_params/mixed_search.rs index 6fba41d3d..be5e2b09f 100644 --- a/crates/akita-planner/src/schedule_params/mixed_search.rs +++ b/crates/akita-planner/src/schedule_params/mixed_search.rs @@ -60,7 +60,6 @@ fn insert_supported( #[allow(clippy::too_many_arguments)] fn suffix_frontier( policy: &PlannerPolicy, - dimensions: &RingDimensionSearchDomain, ring_challenge_config: &dyn Fn(usize) -> Result, fold_shape: &dyn Fn(AkitaScheduleInputs) -> TensorChallengeShape, key: PolynomialGroupLayout, @@ -98,36 +97,61 @@ fn suffix_frontier( 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 crate::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + } = policy.ring_dimension_schedule_mode + else { + return Err(AkitaError::InvalidSetup( + "adaptive search requires adaptive mode".into(), + )); + }; + let candidate_dimensions = if level >= num_search_levels { + vec![ + akita_schedules::planner_support::RingDimensionCandidate::Fixed( + CommitmentRingDims::uniform(uniform_suffix_dimension), + ), + ] + } else { + potential_a_dimensions + .iter() + .copied() + .filter(|&inner| inner <= dimension_ceiling.d_a()) + .map( + |inner| akita_schedules::planner_support::RingDimensionCandidate::Adaptive { + inner, + outer_dimensions: potential_b_dimensions, + opening_dimensions: potential_d_dimensions, + ceiling: dimension_ceiling, + }, + ) + .collect() + }; + for candidate_dimensions in candidate_dimensions { 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(), + candidate_dimensions.inner(), )? else { continue; }; - let Ok(ring_challenge) = ring_challenge_config(candidate_dimensions.d_a()) else { + let Ok(ring_challenge) = ring_challenge_config(candidate_dimensions.inner()) else { continue; }; for &payload_mode in payload_phase.candidate_modes(level, false) { - let candidates = if level < MIXED_SEARCH_FOLD_LEVELS { + let candidates = if level < num_search_levels { derive_candidate_level_params_all_splits( policy, payload_mode, &ring_challenge, - *candidate_dimensions, + candidate_dimensions, input_witness_len, log_basis, level, @@ -139,7 +163,7 @@ fn suffix_frontier( policy, payload_mode, &ring_challenge, - *candidate_dimensions, + candidate_dimensions, input_witness_len, log_basis, level, @@ -151,7 +175,7 @@ fn suffix_frontier( }; for (params, output_witness_len) in candidates { - if level >= MIXED_SEARCH_FOLD_LEVELS { + if level >= num_search_levels { if let Some((mut terminal, terminal_bytes)) = suffix_dp::try_terminal_direct_suffix_cost( input_witness_len, @@ -197,14 +221,13 @@ fn suffix_frontier( } } - let child_ceiling = if level + 1 >= MIXED_SEARCH_FOLD_LEVELS { - CommitmentRingDims::uniform(MIXED_SEARCH_SUFFIX_RING_DIMENSION) + let child_ceiling = if level + 1 >= num_search_levels { + CommitmentRingDims::uniform(uniform_suffix_dimension) } else { params.role_dims() }; for child in suffix_frontier( policy, - dimensions, ring_challenge_config, fold_shape, key, @@ -275,7 +298,6 @@ pub(crate) fn find_schedule( key: PolynomialGroupLayout, policy: &PlannerPolicy, honest_fold_policy: HonestFoldPolicySpec, - dimensions: &RingDimensionSearchDomain, ring_challenge_config: impl Fn(usize) -> Result, fold_shape: impl Fn(AkitaScheduleInputs) -> TensorChallengeShape, ) -> Result { @@ -293,14 +315,33 @@ pub(crate) fn find_schedule( let mut complete = Vec::new(); let schedule_key = AkitaScheduleLookupKey::single(key); + let crate::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension: _, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + } = policy.ring_dimension_schedule_mode + else { + return Err(AkitaError::InvalidSetup( + "adaptive search requires adaptive mode".into(), + )); + }; 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; + for &root_inner in potential_a_dimensions { + let root_dimensions = + akita_schedules::planner_support::RingDimensionCandidate::Adaptive { + inner: root_inner, + outer_dimensions: potential_b_dimensions, + opening_dimensions: potential_d_dimensions, + ceiling: CommitmentRingDims::uniform(policy.uniform_ring_dimension), + }; + let alpha = root_dimensions.inner().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 { + let Ok(ring_challenge) = ring_challenge_config(root_dimensions.inner()) else { continue; }; for (root_params, output_witness_len) in @@ -309,7 +350,7 @@ pub(crate) fn find_schedule( honest_fold_policy, &[], policy, - *root_dimensions, + root_dimensions, &ring_challenge, &ring_challenge_config, root_shape, @@ -324,21 +365,20 @@ pub(crate) fn find_schedule( 0, key, input_witness_len, - root_dimensions.d_a(), + root_dimensions.inner(), )? else { continue; }; for suffix in suffix_frontier( policy, - dimensions, &ring_challenge_config, &fold_shape, key, 1, output_witness_len, log_basis, - *root_dimensions, + root_params.role_dims(), akita_types::CommitmentPayloadPhase::CompressedPrefix, &mut memo, )? { @@ -386,7 +426,7 @@ pub(crate) fn find_schedule( } } - let Some(selected) = select_complete_candidate(policy, complete.iter())?.cloned() else { + let Some(selected) = select_adaptive_candidate(complete, num_search_levels)? else { return Err(AkitaError::UnsupportedSchedule(format!( "no mixed-D schedule with at least two folds for num_vars={}, num_polynomials={}", key.num_vars(), diff --git a/crates/akita-planner/src/schedule_params/objective.rs b/crates/akita-planner/src/schedule_params/objective.rs index 0f2c80e8e..35c9077db 100644 --- a/crates/akita-planner/src/schedule_params/objective.rs +++ b/crates/akita-planner/src/schedule_params/objective.rs @@ -35,7 +35,7 @@ pub(crate) fn complete_schedule_score( setup_field_elements: candidate.setup_field_elements, descriptor, }), - SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload => { + SelectionPolicyId::MinAdaptiveARankDimensionThenSetupAndProof => { Ok(CompleteScheduleScore::MixedDimension { setup_field_elements: candidate.setup_field_elements, proof_bytes: candidate.total_bytes, diff --git a/crates/akita-planner/src/schedule_params/suffix_dp.rs b/crates/akita-planner/src/schedule_params/suffix_dp.rs index 3910e7979..9f1053bcf 100644 --- a/crates/akita-planner/src/schedule_params/suffix_dp.rs +++ b/crates/akita-planner/src/schedule_params/suffix_dp.rs @@ -622,7 +622,7 @@ pub(crate) fn derive_optimal_suffix_schedule( })?, precommitted_honest_fold_policies, policy, - dimensions, + akita_schedules::planner_support::RingDimensionCandidate::Fixed(dimensions), default_ring_challenge_cfg, ring_challenge_config, requested_fold_shape, @@ -646,7 +646,7 @@ pub(crate) fn derive_optimal_suffix_schedule( policy, mode, &ring_challenge_cfg, - dimensions, + akita_schedules::planner_support::RingDimensionCandidate::Fixed(dimensions), current_witness_len, lb, level, diff --git a/crates/akita-planner/src/test/schedule_params.rs b/crates/akita-planner/src/test/schedule_params.rs index 3053926fe..920b4e5c9 100644 --- a/crates/akita-planner/src/test/schedule_params.rs +++ b/crates/akita-planner/src/test/schedule_params.rs @@ -27,14 +27,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 } @@ -133,8 +163,8 @@ fn mixed_domain_search_beats_or_ties_uniform_d64() { let uniform = RingDimensionSearchDomain::uniform(dimensions[0].d_a()).unwrap(); 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, @@ -210,7 +240,6 @@ fn grouped_scalar_fallback_preserves_mixed_domain() { key.final_group, &policy, D256OneHot::root_honest_fold_policy(), - &domain, D256OneHot::ring_challenge_config, D256OneHot::fold_challenge_shape_at_level, ) @@ -228,7 +257,7 @@ fn grouped_scalar_fallback_preserves_mixed_domain() { #[cfg(feature = "catalog-gen")] #[test] -fn pruned_mixed_search_matches_unpruned_traversal_and_is_canonical() { +fn adaptive_mixed_search_is_canonical() { use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; let base_policy = policy_of::(); @@ -252,15 +281,6 @@ fn pruned_mixed_search_matches_unpruned_traversal_and_is_canonical() { D256OneHot::fold_challenge_shape_at_level, ) .unwrap(); - let unpruned = unpruned_search::find_schedule( - key, - &policy, - D256OneHot::root_honest_fold_policy(), - &canonical, - D256OneHot::ring_challenge_config, - D256OneHot::fold_challenge_shape_at_level, - ) - .unwrap(); let repeated = find_schedule( key, &policy, @@ -271,20 +291,10 @@ fn pruned_mixed_search_matches_unpruned_traversal_and_is_canonical() { ) .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() + repeated.schedule.canonical_descriptor_bytes() ); assert_eq!( selected_descriptor, @@ -475,7 +485,7 @@ fn mixed_search_skips_an_unsupported_sis_candidate_and_keeps_its_sibling() { #[cfg(feature = "catalog-gen")] #[test] -fn mixed_nv36_benchmark_policy_selects_minimum_setup_schedule() { +fn adaptive_nv36_selects_minimum_rank_a_path() { use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; let base_policy = policy_of::(); @@ -526,7 +536,11 @@ fn mixed_nv36_benchmark_policy_selects_minimum_setup_schedule() { .params .witness .role_dims(), - CommitmentRingDims::uniform(64) + CommitmentRingDims { + inner: 256, + outer: 64, + opening: 64, + } ); assert_eq!( selected @@ -537,7 +551,7 @@ fn mixed_nv36_benchmark_policy_selects_minimum_setup_schedule() { ); assert_eq!( selected.estimate.estimated_proof_payload_bytes().unwrap(), - 90_312 + 91_128 ); assert_eq!(rank_one_capped_root.inner_commit_matrix.output_rank(), 3); assert_eq!(selected_root.inner_commit_matrix.output_rank(), 1); @@ -572,9 +586,7 @@ fn mixed_search_requires_a_monotonic_d64_suffix_domain() { D256OneHot::fold_challenge_shape_at_level, ) .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), @@ -595,7 +607,7 @@ fn mixed_search_requires_a_monotonic_d64_suffix_domain() { D256OneHot::fold_challenge_shape_at_level, ) .unwrap_err(); - assert!(error.to_string().contains("component-wise at least D64")); + assert!(error.to_string().contains("must be at least suffix D64")); } #[cfg(feature = "catalog-gen")] @@ -671,7 +683,9 @@ fn dimension_domain_is_independent_of_setup_generation_dimension() { 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.ring_dimension_schedule_mode = crate::RingDimensionScheduleMode::UniformDimension { + ring_dimension: 256, + }; policy.selection_policy = crate::SelectionPolicyId::MinEstimatedProofPayload; domain.validate_for_policy(&policy).unwrap(); } diff --git a/crates/akita-planner/src/test/unpruned_search.rs b/crates/akita-planner/src/test/unpruned_search.rs index 154b26756..f0ec8c390 100644 --- a/crates/akita-planner/src/test/unpruned_search.rs +++ b/crates/akita-planner/src/test/unpruned_search.rs @@ -78,7 +78,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, @@ -90,7 +92,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, @@ -262,7 +266,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, root_shape, diff --git a/crates/akita-schedules/src/candidate.rs b/crates/akita-schedules/src/candidate.rs index 94b472a48..a2e63b43a 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 carrier_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, + carrier_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 > carrier_dimension || role_dimension > role_ceiling { + continue; + } + let Some((key, width)) = projected_collision_role_price( + policy, + role, + carrier_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( diff --git a/crates/akita-schedules/src/catalog_identity.rs b/crates/akita-schedules/src/catalog_identity.rs index 9f5ee9623..df54fbd1c 100644 --- a/crates/akita-schedules/src/catalog_identity.rs +++ b/crates/akita-schedules/src/catalog_identity.rs @@ -21,7 +21,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())); @@ -50,7 +50,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); @@ -105,7 +105,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); @@ -150,7 +150,7 @@ struct CatalogIdentityExpectation { recursive_setup_planning: bool, root_fold_shape: TensorChallengeShape, - ring_dimension_candidates: Vec, + ring_dimension_schedule_mode: RingDimensionScheduleMode, ring_dimensions: Vec, ring_challenge_config_digest: u64, key_count: usize, @@ -181,7 +181,7 @@ impl CatalogIdentityExpectation { recursive_setup_planning: identity.recursive_setup_planning, root_fold_shape: identity.root_fold_shape, - 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, @@ -194,12 +194,6 @@ 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, @@ -208,10 +202,9 @@ fn catalog_identity_expectation( fold_challenge_shape_at_level: impl Fn(AkitaScheduleInputs) -> TensorChallengeShape, ) -> Result { let root_fold_shape = root_fold_shape_for_entries(entries, &fold_challenge_shape_at_level)?; - 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 { @@ -235,7 +228,7 @@ fn catalog_identity_expectation( recursive_setup_planning: policy.recursive_setup_planning, root_fold_shape, - ring_dimension_candidates, + ring_dimension_schedule_mode: policy.ring_dimension_schedule_mode, ring_dimensions, ring_challenge_config_digest, key_count: entries.len(), @@ -280,9 +273,7 @@ pub fn expected_catalog_identity( recursive_setup_planning: expected.recursive_setup_planning, root_fold_shape: expected.root_fold_shape, - 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, @@ -367,7 +358,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 { @@ -465,48 +456,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 ))); } @@ -514,6 +511,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); @@ -624,12 +661,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 a8dcc0b3f..2887ef59c 100644 --- a/crates/akita-schedules/src/generated/expand.rs +++ b/crates/akita-schedules/src/generated/expand.rs @@ -972,18 +972,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, @@ -991,7 +985,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 index dffb923ce..14549411f 100644 --- a/crates/akita-schedules/src/generated/fp128_d128_dense.rs +++ b/crates/akita-schedules/src/generated/fp128_d128_dense.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -128,8 +128,6 @@ pub(crate) static FP128_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] @@ -153,7 +151,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - 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: 7, diff --git a/crates/akita-schedules/src/generated/fp128_d128_onehot.rs b/crates/akita-schedules/src/generated/fp128_d128_onehot.rs index 060bb6a60..b4792ad5c 100644 --- a/crates/akita-schedules/src/generated/fp128_d128_onehot.rs +++ b/crates/akita-schedules/src/generated/fp128_d128_onehot.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -124,8 +124,6 @@ pub(crate) static FP128_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] @@ -149,7 +147,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - 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: 7, diff --git a/crates/akita-schedules/src/generated/fp128_d256_onehot.rs b/crates/akita-schedules/src/generated/fp128_d256_onehot.rs index d12c0dd17..5bae753b2 100644 --- a/crates/akita-schedules/src/generated/fp128_d256_onehot.rs +++ b/crates/akita-schedules/src/generated/fp128_d256_onehot.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -44,8 +44,6 @@ pub(crate) static FP128_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] @@ -69,7 +67,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - 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: 2, diff --git a/crates/akita-schedules/src/generated/fp128_d64_dense.rs b/crates/akita-schedules/src/generated/fp128_d64_dense.rs index 8ef08eb51..320d86cee 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_dense.rs +++ b/crates/akita-schedules/src/generated/fp128_d64_dense.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -189,8 +189,6 @@ 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 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; #[rustfmt::skip] @@ -214,7 +212,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 12477507731232336810, key_count: 10, diff --git a/crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk.rs b/crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk.rs index a7ec1716c..c3a647c52 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk.rs +++ b/crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -34,8 +34,6 @@ pub(crate) static FP128_D64_DENSE_MULTI_CHUNK_SCHEDULES: &[GeneratedFoldSchedule }, ]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; #[rustfmt::skip] @@ -59,7 +57,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 8, num_activated_levels: 2 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 12477507731232336810, key_count: 1, diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot.rs index 4cb9f1906..35aae1c3f 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot.rs +++ b/crates/akita-schedules/src/generated/fp128_d64_onehot.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -411,8 +411,6 @@ 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 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; #[rustfmt::skip] @@ -436,7 +434,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 12477507731232336810, key_count: 24, diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk.rs index 9d427fabe..39db9efe2 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk.rs +++ b/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -55,8 +55,6 @@ 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 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; #[rustfmt::skip] @@ -80,7 +78,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 8, num_activated_levels: 2 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 12477507731232336810, key_count: 2, diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w2r2.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w2r2.rs index 418daea4a..300b1af39 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w2r2.rs +++ b/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w2r2.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -50,8 +50,6 @@ 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 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; #[rustfmt::skip] @@ -75,7 +73,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 2, num_activated_levels: 2 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 12477507731232336810, key_count: 2, diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w4r2.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w4r2.rs index 738006b56..d43ad3892 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w4r2.rs +++ b/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w4r2.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -34,8 +34,6 @@ 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 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; #[rustfmt::skip] @@ -59,7 +57,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 4, num_activated_levels: 2 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 12477507731232336810, key_count: 1, diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive.rs index 90ec335a8..bc50a5f0b 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive.rs +++ b/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -37,8 +37,6 @@ pub(crate) static FP128_D64_ONEHOT_RECURSIVE_SCHEDULES: &[GeneratedFoldScheduleE }, ]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; #[rustfmt::skip] @@ -62,7 +60,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: true, root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 12477507731232336810, key_count: 1, diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2.rs index e256d7c24..90b5ebf7c 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2.rs +++ b/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -38,8 +38,6 @@ pub(crate) static FP128_D64_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES: &[Gener }, ]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; #[rustfmt::skip] @@ -63,7 +61,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 8, num_activated_levels: 2 }, recursive_setup_planning: true, root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 12477507731232336810, key_count: 1, diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_tensor.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_tensor.rs index 603b356f6..9a11a3430 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_tensor.rs +++ b/crates/akita-schedules/src/generated/fp128_d64_onehot_tensor.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -34,8 +34,6 @@ pub(crate) static FP128_D64_ONEHOT_TENSOR_SCHEDULES: &[GeneratedFoldScheduleEntr }, ]; -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSION_CANDIDATES: &[CommitmentRingDims] = &[CommitmentRingDims { inner: 64, outer: 64, opening: 64 }]; #[rustfmt::skip] pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; #[rustfmt::skip] @@ -59,7 +57,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Tensor { fold_low_len: 2 }, - ring_dimension_candidates: CATALOG_RING_DIMENSION_CANDIDATES, + ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 12477507731232336810, key_count: 1, diff --git a/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot.rs b/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot.rs index 8d555fdc2..096241831 100644 --- a/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot.rs +++ b/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -17,25 +17,47 @@ 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, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, + 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: 142532, positions_per_block: 512, live_blocks: 279 }, 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: 104951, 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(36, 1), num_digits_inner: 1, num_digits_fold: 3, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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 }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 549146, positions_per_block: 2048, live_blocks: 269 }, 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: 172527, positions_per_block: 4096, live_blocks: 43 }, 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: 21144, 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 }, ], 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 }]; +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, 128, 256]; #[rustfmt::skip] @@ -43,7 +65,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated family_name: "fp128_mixed_dim_onehot", protocol_epoch: 3, cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, + selection_policy: SelectionPolicyId::MinAdaptiveARankDimensionThenSetupAndProof, setup_field_budget: None, min_offloaded_witness_contraction: 3, sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, @@ -59,9 +81,9 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - 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: 3458533356553718245, - key_count: 1, - key_digest: 4854142397157369671, + key_count: 2, + key_digest: 11627159412346705112, }; diff --git a/crates/akita-schedules/src/generated/fp32_d128_onehot.rs b/crates/akita-schedules/src/generated/fp32_d128_onehot.rs index c94fc0f7f..1c97f517b 100644 --- a/crates/akita-schedules/src/generated/fp32_d128_onehot.rs +++ b/crates/akita-schedules/src/generated/fp32_d128_onehot.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -88,8 +88,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] @@ -113,7 +111,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - 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 1c215fe72..3744ed53a 100644 --- a/crates/akita-schedules/src/generated/fp32_d256_onehot.rs +++ b/crates/akita-schedules/src/generated/fp32_d256_onehot.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -31,8 +31,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] @@ -56,7 +54,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - 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 72f4496fa..4b0e75896 100644 --- a/crates/akita-schedules/src/generated/fp64_d128_dense.rs +++ b/crates/akita-schedules/src/generated/fp64_d128_dense.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -47,8 +47,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] @@ -72,7 +70,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - 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 068dab7ab..7360e21e2 100644 --- a/crates/akita-schedules/src/generated/fp64_d128_onehot.rs +++ b/crates/akita-schedules/src/generated/fp64_d128_onehot.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -32,8 +32,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] @@ -57,7 +55,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - 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 841f54a7f..896b67453 100644 --- a/crates/akita-schedules/src/generated/fp64_d256_onehot.rs +++ b/crates/akita-schedules/src/generated/fp64_d256_onehot.rs @@ -8,8 +8,8 @@ use super::{ GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, SelectionPolicyId, SisModulusProfileId, - SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, }; #[rustfmt::skip] @@ -33,8 +33,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] @@ -58,7 +56,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated witness_chunk: ChunkedWitnessCfg { num_chunks: 1, num_activated_levels: 0 }, recursive_setup_planning: false, root_fold_shape: TensorChallengeShape::Flat, - 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 786b521cd..bd23d5dbc 100644 --- a/crates/akita-schedules/src/generated/mod.rs +++ b/crates/akita-schedules/src/generated/mod.rs @@ -160,9 +160,8 @@ pub struct GeneratedScheduleCatalogIdentity { pub recursive_setup_planning: bool, pub root_fold_shape: akita_challenges::TensorChallengeShape, - /// 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, @@ -181,7 +180,7 @@ pub mod validate; pub(crate) mod walk; pub use crate::{ ChunkedWitnessCfg, CommitmentRingDims, DecompositionParams, PlannerCostModelId, - SelectionPolicyId, SisSecurityPolicyId, TensorChallengeShape, + RingDimensionScheduleMode, SelectionPolicyId, SisSecurityPolicyId, TensorChallengeShape, }; pub use akita_types::{ CommitmentPayloadMode, CommittedGroupProfile, InnerCommitMatrixParams, OuterCommitMatrixParams, diff --git a/crates/akita-schedules/src/lib.rs b/crates/akita-schedules/src/lib.rs index 336da9ea6..77c88adb5 100644 --- a/crates/akita-schedules/src/lib.rs +++ b/crates/akita-schedules/src/lib.rs @@ -25,14 +25,16 @@ pub use resolve::{ ResolvedScheduleRow, }; pub use runtime::{ - default_sis_security_policy, PlannerCostModelId, PlannerPolicy, RuntimeSchedulePolicy, - SelectionPolicyId, + default_sis_security_policy, PlannerCostModelId, PlannerPolicy, RingDimensionScheduleMode, + RuntimeSchedulePolicy, SelectionPolicyId, }; /// 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, optimize_fold_challenge_shape, planned_next_witness_len, stage3_payload_bytes_for_successor, validate_policy, diff --git a/crates/akita-schedules/src/runtime.rs b/crates/akita-schedules/src/runtime.rs index 9d50fd2c1..0a35a929b 100644 --- a/crates/akita-schedules/src/runtime.rs +++ b/crates/akita-schedules/src/runtime.rs @@ -39,8 +39,8 @@ impl PlannerCostModelId { pub enum SelectionPolicyId { /// Pick proof bytes, then physical setup fields, then canonical descriptor. MinEstimatedProofPayload, - /// Pick physical setup fields, then proof bytes, then canonical descriptor. - MinSetupMatrixFieldElementsThenProofPayload, + /// Pick per-level A rank/dimension, then setup fields and proof payload. + MinAdaptiveARankDimensionThenSetupAndProof, /// Pick first direct setup, proof bytes, total setup, then descriptor. MinFirstDirectSetupThenPayload, } @@ -49,14 +49,15 @@ 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)] - { - Self::MinSetupMatrixFieldElementsThenProofPayload + } else if matches!( + ring_dimension_schedule_mode, + RingDimensionScheduleMode::AdaptiveDimension { .. } + ) { + Self::MinAdaptiveARankDimensionThenSetupAndProof } else { Self::MinEstimatedProofPayload } @@ -67,7 +68,7 @@ impl SelectionPolicyId { match self { Self::MinEstimatedProofPayload => 1, Self::MinFirstDirectSetupThenPayload => 2, - Self::MinSetupMatrixFieldElementsThenProofPayload => 3, + Self::MinAdaptiveARankDimensionThenSetupAndProof => 4, } } @@ -75,14 +76,52 @@ impl SelectionPolicyId { pub const fn name(self) -> &'static str { match self { Self::MinEstimatedProofPayload => "MinEstimatedProofPayload", - Self::MinSetupMatrixFieldElementsThenProofPayload => { - "MinSetupMatrixFieldElementsThenProofPayload" + Self::MinAdaptiveARankDimensionThenSetupAndProof => { + "MinAdaptiveARankDimensionThenSetupAndProof" } Self::MinFirstDirectSetupThenPayload => "MinFirstDirectSetupThenPayload", } } } +/// 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], + }, +} + +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 @@ -100,11 +139,8 @@ pub struct PlannerPolicy { pub uniform_ring_dimension: usize, /// A-matrix ring dimension used to commit offloaded setup prefixes. 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, @@ -166,8 +202,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 } @@ -217,11 +252,10 @@ pub(crate) 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)?; + 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( @@ -261,21 +295,86 @@ 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 } => { + validate_dimension(policy.uniform_ring_dimension, "uniform", 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 + ))); + } + } + RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, + } => { + if num_search_levels == 0 || num_search_levels > MAX_RECURSION_DEPTH { + return Err(AkitaError::InvalidSetup(format!( + "adaptive search levels must be in 1..={MAX_RECURSION_DEPTH}" + ))); + } + validate_dimension( + policy.uniform_ring_dimension, + "uniform suffix", + uniform_suffix_dimension, + )?; + for (role, dimensions) in [ + ("A", potential_a_dimensions), + ("B", potential_b_dimensions), + ("D", potential_d_dimensions), + ] { + validate_dimension_list(policy.uniform_ring_dimension, role, dimensions)?; + if !dimensions.contains(&uniform_suffix_dimension) { + return Err(AkitaError::InvalidSetup(format!( + "adaptive {role} domain must contain suffix D{uniform_suffix_dimension}" + ))); + } + if dimensions.iter().any(|&d| d < uniform_suffix_dimension) { + return Err(AkitaError::InvalidSetup(format!( + "adaptive {role} dimensions must be at least suffix D{uniform_suffix_dimension}" + ))); + } + } + } } - 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( + setup_dimension: usize, + label: &str, + dimension: usize, +) -> Result<(), AkitaError> { + if dimension == 0 || !dimension.is_power_of_two() || !setup_dimension.is_multiple_of(dimension) + { + return Err(AkitaError::InvalidSetup(format!( + "{label} D{dimension} must be a nonzero power of two dividing setup D{setup_dimension}" + ))); + } + Ok(()) +} + +fn validate_dimension_list( + setup_dimension: usize, + role: &str, + dimensions: &[usize], +) -> Result<(), AkitaError> { + if dimensions.is_empty() { + return Err(AkitaError::InvalidSetup(format!( + "adaptive {role} domain must be nonempty" + ))); + } + for (index, &dimension) in dimensions.iter().enumerate() { + validate_dimension(setup_dimension, role, dimension)?; + if index > 0 && dimensions[index - 1] >= dimension { + return Err(AkitaError::InvalidSetup(format!( + "adaptive {role} domain must be strictly sorted and duplicate-free" + ))); } } Ok(()) From 8a102d24673f229497eefcd8a10eea3917edef0c Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Thu, 6 Aug 2026 11:11:00 -0700 Subject: [PATCH 05/24] feat(config): default fp128 onehot to adaptive dimensions --- book/src/usage/profiling.md | 16 +- book/src/usage/quickstart.md | 15 +- crates/akita-config/Cargo.toml | 4 +- crates/akita-config/src/lib.rs | 14 ++ .../akita-config/src/proof_optimized/fp128.rs | 54 +++--- .../akita-config/src/proof_optimized/tests.rs | 10 +- crates/akita-config/tests/generated_tables.rs | 29 ++-- crates/akita-config/tests/runtime_fallback.rs | 4 +- crates/akita-pcs/examples/profile/main.rs | 17 +- crates/akita-pcs/examples/profile/modes.rs | 20 +-- crates/akita-pcs/src/scheme/tests/onehot.rs | 8 +- .../examples/mixed_dimension_search.rs | 12 +- .../akita-planner/src/generated_families.rs | 37 +---- .../akita-planner/src/test/schedule_params.rs | 4 +- crates/akita-schedules/Cargo.toml | 4 +- .../src/generated/fp128_d128_onehot.rs | 155 ------------------ .../fp128_d128_onehot_precommitted.rs | 15 -- crates/akita-schedules/src/generated/mod.rs | 14 -- scripts/profile_bench_report.py | 5 +- specs/declarative-ring-dimension-policy.md | 22 +-- specs/schedule-catalog-ownership.md | 2 +- specs/y-ring-trace-internalization.md | 2 +- 22 files changed, 125 insertions(+), 338 deletions(-) delete mode 100644 crates/akita-schedules/src/generated/fp128_d128_onehot.rs delete mode 100644 crates/akita-schedules/src/generated/fp128_d128_onehot_precommitted.rs diff --git a/book/src/usage/profiling.md b/book/src/usage/profiling.md index dfcb673c1..883a778e7 100644 --- a/book/src/usage/profiling.md +++ b/book/src/usage/profiling.md @@ -14,6 +14,10 @@ AKITA_MODE=onehot_fp128_d64 AKITA_NUM_VARS=32 \ Run from `crates/akita-pcs/`. The harness refuses debug builds unless `AKITA_ALLOW_DEBUG_PROFILE=1`. +This feature-pruned command intentionally measures the explicit uniform-D64 +baseline. With the normal default feature set, omitting `AKITA_MODE` selects +`onehot_fp128_mixed_dim` at `nv=32`, the adaptive fp128 one-hot default. + 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 @@ -23,9 +27,11 @@ 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. The explicit +uniform `fp128_d64_onehot` baseline remains available, and recursive presets +remain D64. Shipped tables include `fp128_mixed_dim_onehot`, +`fp128_d64_onehot`, `fp128_d64_dense`, and `fp128_d128_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 @@ -39,8 +45,8 @@ Compare ring degrees with | 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_mixed_dim` normally; `onehot_fp128_d64` in the feature-pruned command | Preset family and representation | +| `AKITA_NUM_VARS` | `32` normally; `25` in the feature-pruned D64 binary | Witness size | | `AKITA_NUM_POLYS` | `1` | Batched opening count | | `AKITA_PROFILE_TRACE` | `1` | Chrome/Perfetto trace output | | `AKITA_PROFILE_LOG` | `trace` | `tracing` filter | diff --git a/book/src/usage/quickstart.md b/book/src/usage/quickstart.md index 0febbb433..0c9a530f8 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_mixed_dim`, `AKITA_NUM_VARS=32`). ## Choosing a configuration @@ -23,20 +23,21 @@ 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** | **Adaptive one-hot** (`fp128::OneHot`, explicitly `fp128::AdaptiveOneHot`) | **Default direct one-hot preset.** The generated schedule adapts the first two fold levels and uses D64 afterward. Explicit uniform `fp128::D64OneHot` remains available, and Jolt/recursive presets remain pinned to D64. Shipped tables include adaptive and D64 one-hot plus D64/D128 dense. | | **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. +`best_dense_schedule` to compare the available fp128 presets for a lookup key. +Every preset falls back to the verifier-reachable planner on table miss. **Test harness vs profile defaults.** `crates/akita-pcs/tests/common/mod.rs` uses `fp128::D64OneHot` (one-hot) and `fp128::D64Dense` (dense tests); profile/CI diff --git a/crates/akita-config/Cargo.toml b/crates/akita-config/Cargo.toml index d7d040906..ccd73388d 100644 --- a/crates/akita-config/Cargo.toml +++ b/crates/akita-config/Cargo.toml @@ -21,8 +21,8 @@ default = ["schedules-default"] test-support = [] schedules-default = [ "schedules-fp128-d64-onehot", + "schedules-fp128-mixed-dim-onehot", "schedules-fp128-d64-dense", - "schedules-fp128-d128-onehot", "schedules-fp128-d128-dense", "schedules-fp128-d256-onehot", "schedules-fp32-d128-onehot", @@ -33,7 +33,6 @@ 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-tensor", @@ -51,7 +50,6 @@ schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2 = [ "akita-schedules/fp128-d64-onehot-recursive-multi-chunk-w8r2", ] 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-tensor = ["akita-schedules/fp128-d64-onehot-tensor"] diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index 0fd0bf624..ad9fdb92f 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -657,6 +657,20 @@ mod fp128_policy_tests { /// Spot-check keys aligned with `specs/sis-euclidean-estimator.md` plus table max. const CI_SIS_WIDTH_NUM_VARS: &[usize] = &[14, 16, 28, 30, 44, 50]; + #[test] + fn fp128_default_onehot_is_adaptive() { + 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_dense_schedule_stays_within_audited_sis_widths() { assert_cfg_schedule_stays_within_audited_sis_widths::( diff --git a/crates/akita-config/src/proof_optimized/fp128.rs b/crates/akita-config/src/proof_optimized/fp128.rs index 9d38722bb..246e14863 100644 --- a/crates/akita-config/src/proof_optimized/fp128.rs +++ b/crates/akita-config/src/proof_optimized/fp128.rs @@ -22,29 +22,28 @@ pub struct D64OneHot; #[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; -/// Binary onehot preset with a D256 uniform planner policy and planner-selected +/// Binary onehot preset with D256 setup generation and planner-selected /// per-level 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 AdaptiveOneHot; -impl MixedDimFp128OneHot { +impl AdaptiveOneHot { 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]; } +/// Default fp128 binary onehot preset. +pub type OneHot = AdaptiveOneHot; + /// 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. @@ -86,21 +85,6 @@ impl_proof_optimized_preset!( 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, @@ -157,7 +141,7 @@ impl_proof_optimized_preset!( ) ); impl_proof_optimized_preset!( - MixedDimFp128OneHot, + AdaptiveOneHot, Field, Field, akita_types::SisModulusProfileId::Q128OffsetA7F7, @@ -173,9 +157,9 @@ impl_proof_optimized_preset!( ring_dimension_schedule_mode = akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { num_search_levels: 2, uniform_suffix_dimension: 64, - potential_a_dimensions: &MixedDimFp128OneHot::A_RING_DIMENSIONS, - potential_b_dimensions: &MixedDimFp128OneHot::B_RING_DIMENSIONS, - potential_d_dimensions: &MixedDimFp128OneHot::D_RING_DIMENSIONS, + potential_a_dimensions: &AdaptiveOneHot::A_RING_DIMENSIONS, + potential_b_dimensions: &AdaptiveOneHot::B_RING_DIMENSIONS, + potential_d_dimensions: &AdaptiveOneHot::D_RING_DIMENSIONS, } ); impl_proof_optimized_preset!( @@ -227,23 +211,23 @@ pub enum Fp128Preset { 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, + /// Binary onehot preset with adaptive per-level ring dimensions. + AdaptiveOneHot, } impl Fp128Preset { - /// Ring dimension used by this preset. + /// Setup-generation 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, + Self::D128Dense => 128, + Self::AdaptiveOneHot => 256, } } /// Whether this preset is onehot-oriented. pub const fn is_onehot(self) -> bool { - matches!(self, Self::D64OneHot | Self::D128OneHot) + matches!(self, Self::D64OneHot | Self::AdaptiveOneHot) } /// Stable human-readable preset name. @@ -252,7 +236,7 @@ impl Fp128Preset { Self::D64Dense => "D64Dense", Self::D128Dense => "D128Dense", Self::D64OneHot => "D64OneHot", - Self::D128OneHot => "D128OneHot", + Self::AdaptiveOneHot => "AdaptiveOneHot", } } } @@ -343,7 +327,7 @@ pub fn best_dense_schedule( /// 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. +/// supported preset yields a schedule, so the best available one is returned. /// /// # Errors /// @@ -354,6 +338,6 @@ pub fn best_onehot_schedule( ) -> Result, AkitaError> { Ok(best_by_exact_bytes([ candidate::(Fp128Preset::D64OneHot, key)?, - candidate::(Fp128Preset::D128OneHot, key)?, + candidate::(Fp128Preset::AdaptiveOneHot, key)?, ])) } diff --git a/crates/akita-config/src/proof_optimized/tests.rs b/crates/akita-config/src/proof_optimized/tests.rs index 43fa47989..ed830b366 100644 --- a/crates/akita-config/src/proof_optimized/tests.rs +++ b/crates/akita-config/src/proof_optimized/tests.rs @@ -118,14 +118,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::AdaptiveOneHot::schedule_catalog().expect("adaptive 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::AdaptiveOneHot::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, diff --git a/crates/akita-config/tests/generated_tables.rs b/crates/akita-config/tests/generated_tables.rs index 6a1d25603..3889547fb 100644 --- a/crates/akita-config/tests/generated_tables.rs +++ b/crates/akita-config/tests/generated_tables.rs @@ -73,9 +73,8 @@ 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_mixed_dim_onehot" => fp128::AdaptiveOneHot::schedule_catalog().is_some(), "fp128_d64_onehot" => fp128::D64OneHot::schedule_catalog().is_some(), "fp128_d64_onehot_recursive" => { as CommitmentConfig>::schedule_catalog() @@ -282,8 +281,8 @@ fn equal_lookup_keys_form_one_contiguous_candidate_range() { fn mixed_catalog_identity_binds_nonwinning_dimensions() { static WITHOUT_NONWINNER: &[usize] = &[64, 256]; - let policy = policy_of::(); - let catalog = fp128::MixedDimFp128OneHot::schedule_catalog().expect("mixed catalog"); + let policy = policy_of::(); + let catalog = fp128::AdaptiveOneHot::schedule_catalog().expect("adaptive catalog"); assert!(catalog.entries.iter().all(|entry| entry .root .final_group @@ -314,8 +313,8 @@ fn mixed_catalog_identity_binds_nonwinning_dimensions() { let error = validate_catalog_identity( &mutated, &policy, - fp128::MixedDimFp128OneHot::ring_challenge_config, - fp128::MixedDimFp128OneHot::fold_challenge_shape_at_level, + fp128::AdaptiveOneHot::ring_challenge_config, + fp128::AdaptiveOneHot::fold_challenge_shape_at_level, ) .expect_err("removing an admitted nonwinner must invalidate the catalog"); assert!(error.to_string().contains("catalog identity mismatch")); @@ -347,11 +346,8 @@ fn family_catalog( ) -> 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_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, @@ -411,16 +407,12 @@ fn assert_family_group_batch_table_hit(family: &GeneratedFamily, requests: &[Gro "fp128_d128_dense" => { assert_group_batch_table_hits::(family.module_name, requests) } - "fp128_d128_onehot" => { - 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_mixed_dim_onehot" => { + assert_group_batch_table_hits::(family.module_name, requests) + } "fp128_d64_onehot" => { assert_group_batch_table_hits::(family.module_name, requests) } @@ -511,10 +503,9 @@ fn resolve_family_group_batch_schedule( ) -> 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) + table_backed_group_batch_schedule::(request) } "fp128_d64_onehot" => table_backed_group_batch_schedule::(request), "fp128_d64_onehot_recursive" => table_backed_group_batch_schedule::< diff --git a/crates/akita-config/tests/runtime_fallback.rs b/crates/akita-config/tests/runtime_fallback.rs index 748b7a79c..89fb49797 100644 --- a/crates/akita-config/tests/runtime_fallback.rs +++ b/crates/akita-config/tests/runtime_fallback.rs @@ -306,7 +306,7 @@ fn recursive_adapter_delegates_scalar_keys_to_the_ordinary_catalog() { #[test] fn adapters_forward_mixed_dimension_policy() { - type Base = fp128::MixedDimFp128OneHot; + type Base = fp128::AdaptiveOneHot; assert_eq!( as CommitmentConfig>::RING_DIMENSION_SCHEDULE_MODE, Base::RING_DIMENSION_SCHEDULE_MODE, @@ -390,7 +390,7 @@ 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::(); } diff --git a/crates/akita-pcs/examples/profile/main.rs b/crates/akita-pcs/examples/profile/main.rs index d5ff112b3..1369b578e 100644 --- a/crates/akita-pcs/examples/profile/main.rs +++ b/crates/akita-pcs/examples/profile/main.rs @@ -40,16 +40,23 @@ fn main() { std::process::exit(2); } + let default_nv = if cfg!(feature = "profile-onehot-fp128-d64") { + 25 + } else { + 32 + }; let nv: usize = env::var("AKITA_NUM_VARS") .ok() .and_then(|s| s.parse().ok()) - .unwrap_or(25); + .unwrap_or(default_nv); 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 default_mode = if cfg!(feature = "profile-onehot-fp128-d64") { + "onehot_fp128_d64" + } else { + "onehot_fp128_mixed_dim" + }; + let mode = env::var("AKITA_MODE").unwrap_or_else(|_| default_mode.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) { diff --git a/crates/akita-pcs/examples/profile/modes.rs b/crates/akita-pcs/examples/profile/modes.rs index 2633ee8f9..bf70af5a2 100644 --- a/crates/akita-pcs/examples/profile/modes.rs +++ b/crates/akita-pcs/examples/profile/modes.rs @@ -232,6 +232,10 @@ const PROFILE_ALL_MODES: &[ProfileMode] = &[ name: "onehot_fp128_d64", run: run_profile_onehot_fp128_d64, }, + ProfileMode { + name: "onehot_fp128_mixed_dim", + run: run_profile_onehot_fp128_mixed_dim, + }, ProfileMode { name: "onehot_fp128_d64_multi_group_recursive", run: run_profile_onehot_fp128_d64_multi_group_recursive, @@ -244,10 +248,6 @@ const PROFILE_ALL_MODES: &[ProfileMode] = &[ name: "dense_fp128_d128", run: run_profile_dense_fp128_d128, }, - ProfileMode { - name: "onehot_fp128_d128", - run: run_profile_onehot_fp128_d128, - }, ProfileMode { name: "onehot_fp128_d64_tensor", run: run_profile_onehot_fp128_d64_tensor, @@ -319,7 +319,6 @@ const EXCLUDED_FROM_ALL_SWEEP: &[&str] = &[ // 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", @@ -389,9 +388,9 @@ fn run_profile_onehot_fp128_d64(nv: usize, num_polys: usize) { run_onehot_mode::<{ Cfg::D }, Cfg>("onehot_fp128_d64", &title, nv, num_polys); } -#[cfg(feature = "profile-ci")] +#[cfg(not(feature = "profile-onehot-fp128-d64"))] fn run_profile_onehot_fp128_mixed_dim(nv: usize, num_polys: usize) { - type Cfg = fp128::MixedDimFp128OneHot; + type Cfg = fp128::AdaptiveOneHot; assert!( matches!(nv, 32 | 36), "mixed-dimension profile supports generated nv=32 and nv=36 rows" @@ -559,13 +558,6 @@ fn run_profile_dense_fp128_d128(nv: usize, num_polys: usize) { ); } -#[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; diff --git a/crates/akita-pcs/src/scheme/tests/onehot.rs b/crates/akita-pcs/src/scheme/tests/onehot.rs index 3e2b51506..a5c097596 100644 --- a/crates/akita-pcs/src/scheme/tests/onehot.rs +++ b/crates/akita-pcs/src/scheme/tests/onehot.rs @@ -632,7 +632,7 @@ 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; + crate::test_support::EnvelopeFinalGroupConfig; let pre_layout = OpeningClaimsLayout::new(PRE_NV, 1).expect("precommit layout"); let pre_params = @@ -640,7 +640,7 @@ fn multi_group_root_allows_final_a_smaller_than_precommitted_a() { get_params_for_batched_commitment(&pre_layout) .expect("precommit params"); let test_pre_params = - as CommitmentConfig>:: + as CommitmentConfig>:: get_params_for_batched_commitment(&pre_layout) .expect("test precommit params"); assert_eq!( @@ -659,9 +659,9 @@ fn multi_group_root_allows_final_a_smaller_than_precommitted_a() { 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); + assert_eq!(root.group_role_dims(&opening_layout, 0).unwrap().d_a(), 256); - multi_group_root_round_trip_onehot::( + multi_group_root_round_trip_onehot::( PRE_NV, FINAL_NV, &[1], diff --git a/crates/akita-planner/examples/mixed_dimension_search.rs b/crates/akita-planner/examples/mixed_dimension_search.rs index 6ac6c109b..e0e9cecf3 100644 --- a/crates/akita-planner/examples/mixed_dimension_search.rs +++ b/crates/akita-planner/examples/mixed_dimension_search.rs @@ -1,6 +1,6 @@ use akita_config::{ policy_of, - proof_optimized::fp128::{D64OneHot, MixedDimFp128OneHot}, + proof_optimized::fp128::{AdaptiveOneHot, D64OneHot}, CommitmentConfig, RecursiveCommitmentConfig, }; use akita_planner::find_schedule; @@ -78,22 +78,22 @@ 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(), + AdaptiveOneHot::root_honest_fold_policy(), &[], &direct_policy, - MixedDimFp128OneHot::ring_challenge_config, - MixedDimFp128OneHot::fold_challenge_shape_at_level, + AdaptiveOneHot::ring_challenge_config, + AdaptiveOneHot::fold_challenge_shape_at_level, )?; print_schedule( &format!("direct scalar mixed-D search (nv={num_vars})"), &direct, ); - type MixedRecursive = RecursiveCommitmentConfig; + 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( diff --git a/crates/akita-planner/src/generated_families.rs b/crates/akita-planner/src/generated_families.rs index fbd830415..5252fdff3 100644 --- a/crates/akita-planner/src/generated_families.rs +++ b/crates/akita-planner/src/generated_families.rs @@ -67,16 +67,6 @@ const FP128_D128_DENSE_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(24), ]; -const FP128_D128_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ - PolynomialGroupLayout::singleton(14), - PolynomialGroupLayout::singleton(16), - PolynomialGroupLayout::singleton(20), - PolynomialGroupLayout::new(20, 2), - PolynomialGroupLayout::new(24, 2), - PolynomialGroupLayout::singleton(28), - PolynomialGroupLayout::singleton(32), -]; - const FP128_D64_DENSE_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(14), PolynomialGroupLayout::singleton(16), @@ -260,7 +250,7 @@ fn regen(key: PolynomialGroupLayout) -> Result Result { - type Cfg = fp128::MixedDimFp128OneHot; + type Cfg = fp128::AdaptiveOneHot; let policy = policy_of::(); Ok(find_schedule( &AkitaScheduleLookupKey::single(key), @@ -742,14 +732,6 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ 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", @@ -771,17 +753,16 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ 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::, + 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, + group_batch_keys: group_batch_keys::, + table_backed: table_backed::, + policy: family_policy::, + ring_challenge_config: ::ring_challenge_config, fold_challenge_shape_at_level: - ::fold_challenge_shape_at_level, - precommitted_profiles: precommitted_profiles::, - explicit_precommitted_group: explicit_precommitted_group::, + ::fold_challenge_shape_at_level, + precommitted_profiles: precommitted_profiles::, + explicit_precommitted_group: explicit_precommitted_group::, }, family_row!( recursive, diff --git a/crates/akita-planner/src/test/schedule_params.rs b/crates/akita-planner/src/test/schedule_params.rs index 920b4e5c9..ba12a1fa2 100644 --- a/crates/akita-planner/src/test/schedule_params.rs +++ b/crates/akita-planner/src/test/schedule_params.rs @@ -678,9 +678,9 @@ 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}; + use akita_config::{policy_of, proof_optimized::fp128::D128Dense}; - let mut policy = policy_of::(); + let mut policy = policy_of::(); let domain = RingDimensionSearchDomain::uniform(256).unwrap(); policy.uniform_ring_dimension = 256; policy.ring_dimension_schedule_mode = crate::RingDimensionScheduleMode::UniformDimension { diff --git a/crates/akita-schedules/Cargo.toml b/crates/akita-schedules/Cargo.toml index 93612ddbb..c7afc3af4 100644 --- a/crates/akita-schedules/Cargo.toml +++ b/crates/akita-schedules/Cargo.toml @@ -19,7 +19,6 @@ 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-tensor", @@ -30,8 +29,8 @@ all-schedules = [ ] schedules-default = [ "fp128-d64-onehot", + "fp128-mixed-dim-onehot", "fp128-d64-dense", - "fp128-d128-onehot", "fp128-d128-dense", "fp128-d256-onehot", "fp32-d128-onehot", @@ -45,7 +44,6 @@ 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-tensor = [] 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 b4792ad5c..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, GeneratedRootFinalChallenge, - GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, - GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, - GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, -}; - -#[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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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_DIMENSIONS: &[usize] = &[128]; -#[rustfmt::skip] -pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d128_onehot", - protocol_epoch: 3, - 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, - root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 128 }, - 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/mod.rs b/crates/akita-schedules/src/generated/mod.rs index bd23d5dbc..1ee7282f6 100644 --- a/crates/akita-schedules/src/generated/mod.rs +++ b/crates/akita-schedules/src/generated/mod.rs @@ -461,10 +461,6 @@ pub(crate) fn validate_certified_bases( 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")] @@ -540,16 +536,6 @@ pub fn fp128_d128_dense_table() -> GeneratedScheduleTable { } } -#[cfg(feature = "fp128-d128-onehot")] -pub fn fp128_d128_onehot_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 { diff --git a/scripts/profile_bench_report.py b/scripts/profile_bench_report.py index d531026c8..f02590613 100644 --- a/scripts/profile_bench_report.py +++ b/scripts/profile_bench_report.py @@ -88,8 +88,8 @@ 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 (plus the D64 - # one-hot tensor preset). + # fp128 ships adaptive and D64 one-hot presets, plus D64 tensor and D128 + # dense presets. "dense_fp128_d128": CaseMetadata("fp128", "dense", "dense", "D128"), "onehot_fp128_d64": CaseMetadata("fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64"), "onehot_fp128_mixed_dim": CaseMetadata( @@ -110,7 +110,6 @@ class CaseMetadata: "onehot_fp128_d64_multi_chunk_w4r2": CaseMetadata( "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64 multi-chunk W4R2" ), - "onehot_fp128_d128": CaseMetadata("fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D128"), "onehot_fp128_d64_tensor": CaseMetadata( "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64 tensor" ), diff --git a/specs/declarative-ring-dimension-policy.md b/specs/declarative-ring-dimension-policy.md index 8b19835ad..c8388e241 100644 --- a/specs/declarative-ring-dimension-policy.md +++ b/specs/declarative-ring-dimension-policy.md @@ -88,7 +88,7 @@ The implementation has the following shape: - Generated catalog identity stores the complete enum value and all three ordered adaptive capability lists. Challenge-hook identity covers every A candidate, including non-winners. -- `MixedDimFp128OneHot` uses two searched levels, a D64 uniform suffix, A +- `AdaptiveOneHot` uses two searched levels, a D64 uniform suffix, A candidates `[64, 128, 256]`, and B/D candidates `[64, 128]`. - Adaptive direct multi-chunk and recursive-setup planning remain rejected as specified. Scalar dispatch through a recursive adapter first applies its @@ -134,7 +134,7 @@ This revision makes the following decisions: 3. Keep dimension search bounded by configuration rather than planner constants. 4. Preserve canonical security sizing and verifier-visible schedule data. 5. Admit both D256 direct and D256 three-band paths naturally. -6. Remove planner logic specialized to the name `MixedDimFp128OneHot`. +6. Keep planner logic independent of the concrete `AdaptiveOneHot` preset name. 7. Preserve deterministic generation across machines and executions. ## Non-goals @@ -921,7 +921,7 @@ optional internal consolidation. `mixed_search.rs` may be removed only when: 3. the common frontier implements per-path preprocessing-first semantics; 4. uniform regressions remain unchanged where policy is unchanged; 5. adaptive selections agree with a bounded unpruned reference traversal; and -6. no planner branch refers to `MixedDimFp128OneHot` by name. +6. no planner branch refers to `AdaptiveOneHot` by name. Simply moving the current module's contents into another file is not consolidation. @@ -954,10 +954,10 @@ generated catalog Environment variables must not alter catalog-bound policy during proving or verification. -### Removing MixedDimFp128OneHot special-casing +### Avoiding AdaptiveOneHot special-casing The planner must dispatch on `RingDimensionScheduleMode`, not on the type name -`MixedDimFp128OneHot`. +`AdaptiveOneHot`. Whether the marker type remains temporarily as a concrete catalog/setup policy identity is a separate cleanup decision. The requirement is one canonical @@ -1016,10 +1016,10 @@ The repository currently exercises mixed dimensions through distinct paths. | Experiment | Effective config | Schedule source | | ------------------------------------ | ------------------------------------------------------------------------------------ | ----------------------------------- | -| Stock `onehot_fp128_mixed_dim`, nv32 | `MixedDimFp128OneHot` | Generated runtime catalog | -| Planner diagnostic, nv18–nv40 | Policy derived from `MixedDimFp128OneHot` | Direct offline `find_schedule` call | +| Stock `onehot_fp128_mixed_dim`, nv32 | `AdaptiveOneHot` | Generated runtime catalog | +| Planner diagnostic, nv18–nv40 | Policy derived from `AdaptiveOneHot` | Direct offline `find_schedule` call | | D256 direct timing profile | `MixedDConfig` | Synthetic test-support builder | -| D256 three-band timing profile | `ThreeBandRingDimensionTransitionConfig` | Synthetic test-support builder | +| Historical D256 three-band profile | D256 root, uniform-D128 middle policy, D64 suffix | Synthetic test-support builder | ### Native generated adaptive benchmark @@ -1030,14 +1030,14 @@ The stock mode: AKITA_MODE=onehot_fp128_mixed_dim ``` -uses `fp128::MixedDimFp128OneHot`, fixes nv32, calls +uses `fp128::AdaptiveOneHot`, fixes nv32, calls `Cfg::runtime_schedule`, and gives that exact generated row to the PCS prover and verifier. ### Direct offline diagnostics The `mixed_dimension_search` example derives policy from -`MixedDimFp128OneHot` but calls the offline planner directly. The nv18, nv24, +`AdaptiveOneHot` but calls the offline planner directly. The nv18, nv24, nv32, nv36, and diagnostic over-cap nv40 results discussed in this design review came from this path and are not current runtime catalog rows. @@ -1215,7 +1215,7 @@ The first implementation is complete when: 256/128/128 -> 64/64/64 -> D64 256/128/128 -> 128/64/64 -> D64 ``` -10. Planner logic contains no branch keyed on `MixedDimFp128OneHot`. +10. Planner logic contains no branch keyed on `AdaptiveOneHot`. 11. Runtime remains generated-catalog-only. ## Remaining implementation questions diff --git a/specs/schedule-catalog-ownership.md b/specs/schedule-catalog-ownership.md index 019643eb5..97f164930 100644 --- a/specs/schedule-catalog-ownership.md +++ b/specs/schedule-catalog-ownership.md @@ -733,7 +733,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-mixed-dim-onehot", "schedules-fp128-d128-dense", "schedules-fp32-d128-onehot", "schedules-fp32-d256-onehot", diff --git a/specs/y-ring-trace-internalization.md b/specs/y-ring-trace-internalization.md index 24237787f..fa3ed74f7 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_mixed_dim 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 From 985579cbbc952418b889b14c1716049503d428ea Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Thu, 6 Aug 2026 11:26:30 -0700 Subject: [PATCH 06/24] refactor(schedules): remove fp128 d256 onehot catalog --- crates/akita-config/Cargo.toml | 2 - crates/akita-config/src/lib.rs | 1 + .../akita-config/src/proof_optimized/fp128.rs | 7 +- crates/akita-config/tests/generated_tables.rs | 6 -- crates/akita-pcs/src/scheme/tests/onehot.rs | 36 +++------ .../akita-planner/src/generated_families.rs | 12 --- crates/akita-schedules/Cargo.toml | 2 - .../src/generated/fp128_d256_onehot.rs | 75 ------------------- .../fp128_d256_onehot_precommitted.rs | 15 ---- crates/akita-schedules/src/generated/mod.rs | 14 ---- specs/schedule-catalog-ownership.md | 4 +- 11 files changed, 14 insertions(+), 160 deletions(-) delete mode 100644 crates/akita-schedules/src/generated/fp128_d256_onehot.rs delete mode 100644 crates/akita-schedules/src/generated/fp128_d256_onehot_precommitted.rs diff --git a/crates/akita-config/Cargo.toml b/crates/akita-config/Cargo.toml index ccd73388d..fec85b122 100644 --- a/crates/akita-config/Cargo.toml +++ b/crates/akita-config/Cargo.toml @@ -24,7 +24,6 @@ schedules-default = [ "schedules-fp128-mixed-dim-onehot", "schedules-fp128-d64-dense", "schedules-fp128-d128-dense", - "schedules-fp128-d256-onehot", "schedules-fp32-d128-onehot", "schedules-fp32-d256-onehot", "schedules-fp64-d128-dense", @@ -51,7 +50,6 @@ schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2 = [ ] schedules-fp128-d64-dense = ["akita-schedules/fp128-d64-dense"] schedules-fp128-d128-dense = ["akita-schedules/fp128-d128-dense"] -schedules-fp128-d256-onehot = ["akita-schedules/fp128-d256-onehot"] schedules-fp128-d64-onehot-tensor = ["akita-schedules/fp128-d64-onehot-tensor"] schedules-fp128-d64-onehot-multi-chunk = [ "akita-schedules/fp128-d64-onehot-multi-chunk", diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index ad9fdb92f..6c6abbf2d 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -669,6 +669,7 @@ mod fp128_policy_tests { } )); assert!(fp128::OneHot::schedule_catalog().is_some()); + assert!(fp128::D256OneHot::schedule_catalog().is_none()); } #[test] diff --git a/crates/akita-config/src/proof_optimized/fp128.rs b/crates/akita-config/src/proof_optimized/fp128.rs index 246e14863..0016236d6 100644 --- a/crates/akita-config/src/proof_optimized/fp128.rs +++ b/crates/akita-config/src/proof_optimized/fp128.rs @@ -133,12 +133,7 @@ impl_proof_optimized_preset!( 256, 128, 1, - fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 1), - schedules = ( - "schedules-fp128-d256-onehot", - "fp128_d256_onehot", - fp128_d256_onehot_table - ) + fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 1) ); impl_proof_optimized_preset!( AdaptiveOneHot, diff --git a/crates/akita-config/tests/generated_tables.rs b/crates/akita-config/tests/generated_tables.rs index 3889547fb..2c7bd9d61 100644 --- a/crates/akita-config/tests/generated_tables.rs +++ b/crates/akita-config/tests/generated_tables.rs @@ -73,7 +73,6 @@ 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_d256_onehot" => fp128::D256OneHot::schedule_catalog().is_some(), "fp128_mixed_dim_onehot" => fp128::AdaptiveOneHot::schedule_catalog().is_some(), "fp128_d64_onehot" => fp128::D64OneHot::schedule_catalog().is_some(), "fp128_d64_onehot_recursive" => { @@ -346,7 +345,6 @@ fn family_catalog( ) -> akita_schedules::GeneratedScheduleTable { match family.module_name { "fp128_d128_dense" => 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::< @@ -407,9 +405,6 @@ fn assert_family_group_batch_table_hit(family: &GeneratedFamily, requests: &[Gro "fp128_d128_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) } @@ -503,7 +498,6 @@ fn resolve_family_group_batch_schedule( ) -> Result { match family.module_name { "fp128_d128_dense" => 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) } diff --git a/crates/akita-pcs/src/scheme/tests/onehot.rs b/crates/akita-pcs/src/scheme/tests/onehot.rs index a5c097596..1ff61c025 100644 --- a/crates/akita-pcs/src/scheme/tests/onehot.rs +++ b/crates/akita-pcs/src/scheme/tests/onehot.rs @@ -634,40 +634,24 @@ fn multi_group_root_allows_final_a_smaller_than_precommitted_a() { 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 pre_group = akita_types::PolynomialGroupLayout::new(PRE_NV, 1); + let precommitted = akita_planner::derive_standalone_precommit_profile( + pre_group, + &akita_config::policy_of::(), + fp128::D256OneHot::root_honest_fold_policy(), + fp128::D256OneHot::ring_challenge_config, + fp128::D256OneHot::fold_challenge_shape_at_level, + ) + .expect("synthetic D256 precommit profile"); 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, - )], + precommitteds: vec![precommitted], }; 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(), 256); - - multi_group_root_round_trip_onehot::( - PRE_NV, - FINAL_NV, - &[1], - 2, - true, - ); } #[test] diff --git a/crates/akita-planner/src/generated_families.rs b/crates/akita-planner/src/generated_families.rs index 5252fdff3..e4840c730 100644 --- a/crates/akita-planner/src/generated_families.rs +++ b/crates/akita-planner/src/generated_families.rs @@ -102,11 +102,6 @@ const FP128_D64_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(50), ]; -const FP128_D256_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ - PolynomialGroupLayout::singleton(14), - PolynomialGroupLayout::singleton(16), -]; - const FP128_MIXED_DIM_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(32), PolynomialGroupLayout::singleton(36), @@ -740,13 +735,6 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ 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", diff --git a/crates/akita-schedules/Cargo.toml b/crates/akita-schedules/Cargo.toml index c7afc3af4..e84cd63ab 100644 --- a/crates/akita-schedules/Cargo.toml +++ b/crates/akita-schedules/Cargo.toml @@ -32,7 +32,6 @@ schedules-default = [ "fp128-mixed-dim-onehot", "fp128-d64-dense", "fp128-d128-dense", - "fp128-d256-onehot", "fp32-d128-onehot", "fp32-d256-onehot", "fp64-d128-dense", @@ -45,7 +44,6 @@ fp128-d64-onehot-recursive = [] fp128-d64-onehot-recursive-multi-chunk-w8r2 = [] fp128-d64-dense = [] fp128-d128-dense = [] -fp128-d256-onehot = [] fp128-d64-onehot-tensor = [] fp128-d64-onehot-multi-chunk = [] fp128-d64-onehot-multi-chunk-w2r2 = [] 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 5bae753b2..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, GeneratedRootFinalChallenge, - GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, - GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, - GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, -}; - -#[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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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_DIMENSIONS: &[usize] = &[256]; -#[rustfmt::skip] -pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d256_onehot", - protocol_epoch: 3, - 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, - root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 256 }, - 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/mod.rs b/crates/akita-schedules/src/generated/mod.rs index 1ee7282f6..480cbacc9 100644 --- a/crates/akita-schedules/src/generated/mod.rs +++ b/crates/akita-schedules/src/generated/mod.rs @@ -461,10 +461,6 @@ pub(crate) fn validate_certified_bases( pub mod fp128_d128_dense; #[cfg(feature = "fp128-d128-dense")] pub mod fp128_d128_dense_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")] @@ -536,16 +532,6 @@ pub fn fp128_d128_dense_table() -> GeneratedScheduleTable { } } -#[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, - } -} - #[cfg(feature = "fp128-d64-dense")] pub fn fp128_d64_dense_table() -> GeneratedScheduleTable { GeneratedScheduleTable { diff --git a/specs/schedule-catalog-ownership.md b/specs/schedule-catalog-ownership.md index 97f164930..514034dd3 100644 --- a/specs/schedule-catalog-ownership.md +++ b/specs/schedule-catalog-ownership.md @@ -916,8 +916,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. From 45169d9ce194a6dbc121273af60903e53485c40b Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Thu, 6 Aug 2026 12:11:20 -0700 Subject: [PATCH 07/24] refactor(config): canonicalize fp128 onehot naming --- .github/workflows/profile-bench.yml | 12 +++---- book/src/usage/profiling.md | 6 ++-- book/src/usage/quickstart.md | 4 +-- crates/akita-config/Cargo.toml | 4 +-- crates/akita-config/src/lib.rs | 2 +- .../akita-config/src/proof_optimized/fp128.rs | 33 +++++++----------- .../akita-config/src/proof_optimized/tests.rs | 4 +-- crates/akita-config/tests/generated_tables.rs | 20 +++++------ crates/akita-config/tests/runtime_fallback.rs | 4 +-- crates/akita-pcs/Cargo.toml | 2 +- crates/akita-pcs/examples/profile/main.rs | 2 +- crates/akita-pcs/examples/profile/modes.rs | 30 +++++++--------- .../examples/mixed_dimension_search.rs | 12 +++---- .../akita-planner/src/generated_families.rs | 34 +++++++++---------- crates/akita-schedules/Cargo.toml | 4 +-- ...28_mixed_dim_onehot.rs => fp128_onehot.rs} | 4 +-- ...mitted.rs => fp128_onehot_precommitted.rs} | 2 +- crates/akita-schedules/src/generated/mod.rs | 19 ++++++----- scripts/check_profile_ci_features.sh | 2 +- scripts/profile_bench_report.py | 8 ++--- specs/declarative-ring-dimension-policy.md | 28 +++++++-------- specs/mixed-ring-dimension-per-level.md | 2 +- specs/schedule-catalog-ownership.md | 2 +- specs/y-ring-trace-internalization.md | 2 +- 24 files changed, 113 insertions(+), 129 deletions(-) rename crates/akita-schedules/src/generated/{fp128_mixed_dim_onehot.rs => fp128_onehot.rs} (99%) rename crates/akita-schedules/src/generated/{fp128_mixed_dim_onehot_precommitted.rs => fp128_onehot_precommitted.rs} (97%) diff --git a/.github/workflows/profile-bench.yml b/.github/workflows/profile-bench.yml index 5fa927e85..86f486563 100644 --- a/.github/workflows/profile-bench.yml +++ b/.github/workflows/profile-bench.yml @@ -24,12 +24,10 @@ 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. Explicit + # D64 rows remain in the matrix as uniform and recursive/distributed + # comparison profiles. + 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 @@ -85,7 +83,7 @@ jobs: onehot_fp32_d128:28:1 onehot_fp64_d128:28:1 onehot_fp128_d64:32:1 - onehot_fp128_mixed_dim:32:1 + onehot_fp128:32:1 onehot_fp128_d64:30:4 - name: 4-multi-group-recursive-direct cases: | diff --git a/book/src/usage/profiling.md b/book/src/usage/profiling.md index 883a778e7..e24f3a78e 100644 --- a/book/src/usage/profiling.md +++ b/book/src/usage/profiling.md @@ -16,7 +16,7 @@ Run from `crates/akita-pcs/`. The harness refuses debug builds unless This feature-pruned command intentionally measures the explicit uniform-D64 baseline. With the normal default feature set, omitting `AKITA_MODE` selects -`onehot_fp128_mixed_dim` at `nv=32`, the adaptive fp128 one-hot default. +`onehot_fp128` at `nv=32`, the default fp128 one-hot 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 @@ -30,7 +30,7 @@ normal release link look like a verifier regression. The default direct **fp128** one-hot preset is adaptive: generated tables choose the first two fold levels and use D64 for the uniform suffix. The explicit uniform `fp128_d64_onehot` baseline remains available, and recursive presets -remain D64. Shipped tables include `fp128_mixed_dim_onehot`, +remain D64. Shipped tables include `fp128_onehot`, `fp128_d64_onehot`, `fp128_d64_dense`, and `fp128_d128_dense`. **fp128 D=32** is not a valid A-role fold degree (`d_a ≥ 64`); there is no `D32OneHot` preset. @@ -45,7 +45,7 @@ Compare ring degrees with | Variable | Default | Purpose | |----------|---------|---------| -| `AKITA_MODE` | `onehot_fp128_mixed_dim` normally; `onehot_fp128_d64` in the feature-pruned command | Preset family and representation | +| `AKITA_MODE` | `onehot_fp128` normally; `onehot_fp128_d64` in the feature-pruned command | Preset family and representation | | `AKITA_NUM_VARS` | `32` normally; `25` in the feature-pruned D64 binary | Witness size | | `AKITA_NUM_POLYS` | `1` | Batched opening count | | `AKITA_PROFILE_TRACE` | `1` | Chrome/Perfetto trace output | diff --git a/book/src/usage/quickstart.md b/book/src/usage/quickstart.md index 0c9a530f8..370996e66 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_mixed_dim`, `AKITA_NUM_VARS=32`). + (`AKITA_MODE=onehot_fp128`, `AKITA_NUM_VARS=32`). ## Choosing a configuration @@ -32,7 +32,7 @@ one-hot preset now chooses dimensions per fold from generated adaptive tables; | Field | Typical production choice | Notes | |-------|---------------------------|--------| -| **fp128** | **Adaptive one-hot** (`fp128::OneHot`, explicitly `fp128::AdaptiveOneHot`) | **Default direct one-hot preset.** The generated schedule adapts the first two fold levels and uses D64 afterward. Explicit uniform `fp128::D64OneHot` remains available, and Jolt/recursive presets remain pinned to D64. Shipped tables include adaptive and D64 one-hot plus D64/D128 dense. | +| **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. Explicit uniform `fp128::D64OneHot` remains available, and Jolt/recursive presets remain pinned to D64. Shipped tables include the default and D64 one-hot families plus D64/D128 dense. | | **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` / diff --git a/crates/akita-config/Cargo.toml b/crates/akita-config/Cargo.toml index fec85b122..e338f68cc 100644 --- a/crates/akita-config/Cargo.toml +++ b/crates/akita-config/Cargo.toml @@ -21,7 +21,7 @@ default = ["schedules-default"] test-support = [] schedules-default = [ "schedules-fp128-d64-onehot", - "schedules-fp128-mixed-dim-onehot", + "schedules-fp128-onehot", "schedules-fp128-d64-dense", "schedules-fp128-d128-dense", "schedules-fp32-d128-onehot", @@ -41,7 +41,7 @@ all-schedules = [ "schedules-fp128-d64-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-onehot = ["akita-schedules/fp128-onehot"] schedules-fp128-d64-onehot-recursive = [ "akita-schedules/fp128-d64-onehot-recursive", ] diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index 6c6abbf2d..e83a37fbd 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -658,7 +658,7 @@ mod fp128_policy_tests { const CI_SIS_WIDTH_NUM_VARS: &[usize] = &[14, 16, 28, 30, 44, 50]; #[test] - fn fp128_default_onehot_is_adaptive() { + fn fp128_onehot_uses_adaptive_schedule_policy() { assert_eq!(::D, 256); assert!(matches!( ::RING_DIMENSION_SCHEDULE_MODE, diff --git a/crates/akita-config/src/proof_optimized/fp128.rs b/crates/akita-config/src/proof_optimized/fp128.rs index 0016236d6..8dd88d1a6 100644 --- a/crates/akita-config/src/proof_optimized/fp128.rs +++ b/crates/akita-config/src/proof_optimized/fp128.rs @@ -27,23 +27,20 @@ pub struct D64OneHotK16; #[derive(Clone, Copy, Debug, Default)] pub struct D256OneHot; -/// Binary onehot preset with D256 setup generation and planner-selected +/// Default binary onehot preset with D256 setup generation and planner-selected /// per-level 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 AdaptiveOneHot; +pub struct OneHot; -impl AdaptiveOneHot { +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]; } -/// Default fp128 binary onehot preset. -pub type OneHot = AdaptiveOneHot; - /// 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. @@ -136,7 +133,7 @@ impl_proof_optimized_preset!( fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 1) ); impl_proof_optimized_preset!( - AdaptiveOneHot, + OneHot, Field, Field, akita_types::SisModulusProfileId::Q128OffsetA7F7, @@ -144,17 +141,13 @@ 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 - ), + schedules = ("schedules-fp128-onehot", "fp128_onehot", fp128_onehot_table), ring_dimension_schedule_mode = akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { num_search_levels: 2, uniform_suffix_dimension: 64, - potential_a_dimensions: &AdaptiveOneHot::A_RING_DIMENSIONS, - potential_b_dimensions: &AdaptiveOneHot::B_RING_DIMENSIONS, - potential_d_dimensions: &AdaptiveOneHot::D_RING_DIMENSIONS, + potential_a_dimensions: &OneHot::A_RING_DIMENSIONS, + potential_b_dimensions: &OneHot::B_RING_DIMENSIONS, + potential_d_dimensions: &OneHot::D_RING_DIMENSIONS, } ); impl_proof_optimized_preset!( @@ -207,7 +200,7 @@ pub enum Fp128Preset { /// Binary onehot generated `D=64` preset. D64OneHot, /// Binary onehot preset with adaptive per-level ring dimensions. - AdaptiveOneHot, + OneHot, } impl Fp128Preset { @@ -216,13 +209,13 @@ impl Fp128Preset { match self { Self::D64Dense | Self::D64OneHot => 64, Self::D128Dense => 128, - Self::AdaptiveOneHot => 256, + Self::OneHot => 256, } } /// Whether this preset is onehot-oriented. pub const fn is_onehot(self) -> bool { - matches!(self, Self::D64OneHot | Self::AdaptiveOneHot) + matches!(self, Self::D64OneHot | Self::OneHot) } /// Stable human-readable preset name. @@ -231,7 +224,7 @@ impl Fp128Preset { Self::D64Dense => "D64Dense", Self::D128Dense => "D128Dense", Self::D64OneHot => "D64OneHot", - Self::AdaptiveOneHot => "AdaptiveOneHot", + Self::OneHot => "OneHot", } } } @@ -333,6 +326,6 @@ pub fn best_onehot_schedule( ) -> Result, AkitaError> { Ok(best_by_exact_bytes([ candidate::(Fp128Preset::D64OneHot, key)?, - candidate::(Fp128Preset::AdaptiveOneHot, key)?, + candidate::(Fp128Preset::OneHot, key)?, ])) } diff --git a/crates/akita-config/src/proof_optimized/tests.rs b/crates/akita-config/src/proof_optimized/tests.rs index ed830b366..4a1b07a61 100644 --- a/crates/akita-config/src/proof_optimized/tests.rs +++ b/crates/akita-config/src/proof_optimized/tests.rs @@ -119,12 +119,12 @@ fn generated_q32_terminals_require_the_i16_tail() { #[cfg(feature = "schedules-default")] #[test] fn fp128_adaptive_onehot_catalog_freezes_root_fold_digits() { - let table = fp128::AdaptiveOneHot::schedule_catalog().expect("adaptive one-hot catalog"); + let table = fp128::OneHot::schedule_catalog().expect("fp128 one-hot catalog"); let first = table .entries .first() .expect("nonempty adaptive one-hot catalog"); - let schedule = fp128::AdaptiveOneHot::runtime_schedule(first.to_runtime_lookup_key()) + 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!( diff --git a/crates/akita-config/tests/generated_tables.rs b/crates/akita-config/tests/generated_tables.rs index 2c7bd9d61..525ed43bc 100644 --- a/crates/akita-config/tests/generated_tables.rs +++ b/crates/akita-config/tests/generated_tables.rs @@ -73,7 +73,7 @@ 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_mixed_dim_onehot" => fp128::AdaptiveOneHot::schedule_catalog().is_some(), + "fp128_onehot" => fp128::OneHot::schedule_catalog().is_some(), "fp128_d64_onehot" => fp128::D64OneHot::schedule_catalog().is_some(), "fp128_d64_onehot_recursive" => { as CommitmentConfig>::schedule_catalog() @@ -280,8 +280,8 @@ fn equal_lookup_keys_form_one_contiguous_candidate_range() { fn mixed_catalog_identity_binds_nonwinning_dimensions() { static WITHOUT_NONWINNER: &[usize] = &[64, 256]; - let policy = policy_of::(); - let catalog = fp128::AdaptiveOneHot::schedule_catalog().expect("adaptive catalog"); + let policy = policy_of::(); + let catalog = fp128::OneHot::schedule_catalog().expect("fp128 one-hot catalog"); assert!(catalog.entries.iter().all(|entry| entry .root .final_group @@ -312,8 +312,8 @@ fn mixed_catalog_identity_binds_nonwinning_dimensions() { let error = validate_catalog_identity( &mutated, &policy, - fp128::AdaptiveOneHot::ring_challenge_config, - fp128::AdaptiveOneHot::fold_challenge_shape_at_level, + fp128::OneHot::ring_challenge_config, + fp128::OneHot::fold_challenge_shape_at_level, ) .expect_err("removing an admitted nonwinner must invalidate the catalog"); assert!(error.to_string().contains("catalog identity mismatch")); @@ -345,7 +345,7 @@ fn family_catalog( ) -> akita_schedules::GeneratedScheduleTable { match family.module_name { "fp128_d128_dense" => prepare_family_catalog::(family, keys), - "fp128_mixed_dim_onehot" => prepare_family_catalog::(family, keys), + "fp128_onehot" => prepare_family_catalog::(family, keys), "fp128_d64_onehot" => prepare_family_catalog::(family, keys), "fp128_d64_onehot_recursive" => prepare_family_catalog::< akita_config::RecursiveCommitmentConfig, @@ -405,8 +405,8 @@ fn assert_family_group_batch_table_hit(family: &GeneratedFamily, requests: &[Gro "fp128_d128_dense" => { assert_group_batch_table_hits::(family.module_name, requests) } - "fp128_mixed_dim_onehot" => { - assert_group_batch_table_hits::(family.module_name, requests) + "fp128_onehot" => { + assert_group_batch_table_hits::(family.module_name, requests) } "fp128_d64_onehot" => { assert_group_batch_table_hits::(family.module_name, requests) @@ -498,9 +498,7 @@ fn resolve_family_group_batch_schedule( ) -> Result { match family.module_name { "fp128_d128_dense" => table_backed_group_batch_schedule::(request), - "fp128_mixed_dim_onehot" => { - table_backed_group_batch_schedule::(request) - } + "fp128_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, diff --git a/crates/akita-config/tests/runtime_fallback.rs b/crates/akita-config/tests/runtime_fallback.rs index 89fb49797..8e6e064a2 100644 --- a/crates/akita-config/tests/runtime_fallback.rs +++ b/crates/akita-config/tests/runtime_fallback.rs @@ -306,7 +306,7 @@ fn recursive_adapter_delegates_scalar_keys_to_the_ordinary_catalog() { #[test] fn adapters_forward_mixed_dimension_policy() { - type Base = fp128::AdaptiveOneHot; + type Base = fp128::OneHot; assert_eq!( as CommitmentConfig>::RING_DIMENSION_SCHEDULE_MODE, Base::RING_DIMENSION_SCHEDULE_MODE, @@ -390,7 +390,7 @@ 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::(); } diff --git a/crates/akita-pcs/Cargo.toml b/crates/akita-pcs/Cargo.toml index c27eea7ce..b708590af 100644 --- a/crates/akita-pcs/Cargo.toml +++ b/crates/akita-pcs/Cargo.toml @@ -46,7 +46,7 @@ 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", diff --git a/crates/akita-pcs/examples/profile/main.rs b/crates/akita-pcs/examples/profile/main.rs index 1369b578e..67e3f9d69 100644 --- a/crates/akita-pcs/examples/profile/main.rs +++ b/crates/akita-pcs/examples/profile/main.rs @@ -54,7 +54,7 @@ fn main() { let default_mode = if cfg!(feature = "profile-onehot-fp128-d64") { "onehot_fp128_d64" } else { - "onehot_fp128_mixed_dim" + "onehot_fp128" }; let mode = env::var("AKITA_MODE").unwrap_or_else(|_| default_mode.to_string()); let enable_trace = env_flag("AKITA_PROFILE_TRACE", true); diff --git a/crates/akita-pcs/examples/profile/modes.rs b/crates/akita-pcs/examples/profile/modes.rs index bf70af5a2..8667bcb7a 100644 --- a/crates/akita-pcs/examples/profile/modes.rs +++ b/crates/akita-pcs/examples/profile/modes.rs @@ -185,8 +185,8 @@ const PROFILE_CI_MODES: &[ProfileMode] = &[ run: run_profile_onehot_fp128_d64, }, ProfileMode { - name: "onehot_fp128_mixed_dim", - run: run_profile_onehot_fp128_mixed_dim, + name: "onehot_fp128", + run: run_profile_onehot_fp128, }, ProfileMode { name: "onehot_fp128_d64_multi_group_recursive", @@ -233,8 +233,8 @@ const PROFILE_ALL_MODES: &[ProfileMode] = &[ run: run_profile_onehot_fp128_d64, }, ProfileMode { - name: "onehot_fp128_mixed_dim", - run: run_profile_onehot_fp128_mixed_dim, + name: "onehot_fp128", + run: run_profile_onehot_fp128, }, ProfileMode { name: "onehot_fp128_d64_multi_group_recursive", @@ -389,18 +389,18 @@ fn run_profile_onehot_fp128_d64(nv: usize, num_polys: usize) { } #[cfg(not(feature = "profile-onehot-fp128-d64"))] -fn run_profile_onehot_fp128_mixed_dim(nv: usize, num_polys: usize) { - type Cfg = fp128::AdaptiveOneHot; +fn run_profile_onehot_fp128(nv: usize, num_polys: usize) { + type Cfg = fp128::OneHot; assert!( matches!(nv, 32 | 36), - "mixed-dimension profile supports generated nv=32 and nv=36 rows" + "fp128 one-hot profile supports generated nv=32 and nv=36 rows" ); - assert_singleton_mode("onehot_fp128_mixed_dim", num_polys); + 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 @@ -411,24 +411,18 @@ 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 diff --git a/crates/akita-planner/examples/mixed_dimension_search.rs b/crates/akita-planner/examples/mixed_dimension_search.rs index e0e9cecf3..51a5864cd 100644 --- a/crates/akita-planner/examples/mixed_dimension_search.rs +++ b/crates/akita-planner/examples/mixed_dimension_search.rs @@ -1,6 +1,6 @@ use akita_config::{ policy_of, - proof_optimized::fp128::{AdaptiveOneHot, D64OneHot}, + proof_optimized::fp128::{D64OneHot, OneHot}, CommitmentConfig, RecursiveCommitmentConfig, }; use akita_planner::find_schedule; @@ -78,22 +78,22 @@ 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, - AdaptiveOneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &[], &direct_policy, - AdaptiveOneHot::ring_challenge_config, - AdaptiveOneHot::fold_challenge_shape_at_level, + OneHot::ring_challenge_config, + OneHot::fold_challenge_shape_at_level, )?; print_schedule( &format!("direct scalar mixed-D search (nv={num_vars})"), &direct, ); - type MixedRecursive = RecursiveCommitmentConfig; + 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( diff --git a/crates/akita-planner/src/generated_families.rs b/crates/akita-planner/src/generated_families.rs index e4840c730..fb7ffcb53 100644 --- a/crates/akita-planner/src/generated_families.rs +++ b/crates/akita-planner/src/generated_families.rs @@ -102,7 +102,7 @@ const FP128_D64_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(50), ]; -const FP128_MIXED_DIM_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ +const FP128_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(32), PolynomialGroupLayout::singleton(36), ]; @@ -243,9 +243,9 @@ fn regen(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::AdaptiveOneHot; +/// 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), @@ -736,21 +736,21 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ fp128::D64OneHot ), 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::, + 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: false, - group_batch_keys: group_batch_keys::, - table_backed: table_backed::, - policy: family_policy::, - ring_challenge_config: ::ring_challenge_config, + group_batch_keys: group_batch_keys::, + table_backed: table_backed::, + policy: family_policy::, + ring_challenge_config: ::ring_challenge_config, fold_challenge_shape_at_level: - ::fold_challenge_shape_at_level, - precommitted_profiles: precommitted_profiles::, - explicit_precommitted_group: explicit_precommitted_group::, + ::fold_challenge_shape_at_level, + precommitted_profiles: precommitted_profiles::, + explicit_precommitted_group: explicit_precommitted_group::, }, family_row!( recursive, diff --git a/crates/akita-schedules/Cargo.toml b/crates/akita-schedules/Cargo.toml index e84cd63ab..28e1bdd27 100644 --- a/crates/akita-schedules/Cargo.toml +++ b/crates/akita-schedules/Cargo.toml @@ -29,7 +29,7 @@ all-schedules = [ ] schedules-default = [ "fp128-d64-onehot", - "fp128-mixed-dim-onehot", + "fp128-onehot", "fp128-d64-dense", "fp128-d128-dense", "fp32-d128-onehot", @@ -39,7 +39,7 @@ schedules-default = [ "fp64-d256-onehot", ] fp128-d64-onehot = [] -fp128-mixed-dim-onehot = [] +fp128-onehot = [] fp128-d64-onehot-recursive = [] fp128-d64-onehot-recursive-multi-chunk-w8r2 = [] fp128-d64-dense = [] diff --git a/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot.rs b/crates/akita-schedules/src/generated/fp128_onehot.rs similarity index 99% rename from crates/akita-schedules/src/generated/fp128_mixed_dim_onehot.rs rename to crates/akita-schedules/src/generated/fp128_onehot.rs index 096241831..8e6f572b6 100644 --- a/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot.rs @@ -13,7 +13,7 @@ use super::{ }; #[rustfmt::skip] -pub(crate) static FP128_MIXED_DIM_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ +pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(32, 1), num_digits_inner: 1, num_digits_fold: 3, challenge: GeneratedRootFinalChallenge::Flat, @@ -62,7 +62,7 @@ pub(crate) static CATALOG_POTENTIAL_D_DIMENSIONS: &[usize] = &[64, 128]; 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", + family_name: "fp128_onehot", protocol_epoch: 3, cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, selection_policy: SelectionPolicyId::MinAdaptiveARankDimensionThenSetupAndProof, diff --git a/crates/akita-schedules/src/generated/fp128_mixed_dim_onehot_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs similarity index 97% rename from crates/akita-schedules/src/generated/fp128_mixed_dim_onehot_precommitted.rs rename to crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs index 9334d93ee..5740c5f8d 100644 --- a/crates/akita-schedules/src/generated/fp128_mixed_dim_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_MIXED_DIM_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: 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 }, diff --git a/crates/akita-schedules/src/generated/mod.rs b/crates/akita-schedules/src/generated/mod.rs index 480cbacc9..d7ce7b816 100644 --- a/crates/akita-schedules/src/generated/mod.rs +++ b/crates/akita-schedules/src/generated/mod.rs @@ -497,10 +497,10 @@ pub mod fp128_d64_onehot_recursive_precommitted; pub mod fp128_d64_onehot_tensor; #[cfg(feature = "fp128-d64-onehot-tensor")] pub mod fp128_d64_onehot_tensor_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-onehot")] +pub mod fp128_onehot; +#[cfg(feature = "fp128-onehot")] +pub mod fp128_onehot_precommitted; #[cfg(feature = "fp32-d128-onehot")] pub mod fp32_d128_onehot; #[cfg(feature = "fp32-d128-onehot")] @@ -615,12 +615,13 @@ pub fn fp128_d64_onehot_tensor_table() -> GeneratedScheduleTable { } } -#[cfg(feature = "fp128-mixed-dim-onehot")] -pub fn fp128_mixed_dim_onehot_table() -> GeneratedScheduleTable { +#[cfg(feature = "fp128-onehot")] +pub fn fp128_onehot_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::FP128_ONEHOT_SCHEDULES, + precommitted_profiles: + fp128_onehot_precommitted::FP128_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES, + identity: fp128_onehot::CATALOG_IDENTITY, } } diff --git a/scripts/check_profile_ci_features.sh b/scripts/check_profile_ci_features.sh index 2d35dd97e..a7ca1e111 100755 --- a/scripts/check_profile_ci_features.sh +++ b/scripts/check_profile_ci_features.sh @@ -21,7 +21,7 @@ MODE_FEATURE = { "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": "schedules-fp128-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_tensor": "schedules-fp128-d64-onehot-tensor", diff --git a/scripts/profile_bench_report.py b/scripts/profile_bench_report.py index f02590613..783b5abfb 100644 --- a/scripts/profile_bench_report.py +++ b/scripts/profile_bench_report.py @@ -88,11 +88,11 @@ 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 adaptive and D64 one-hot presets, plus D64 tensor and D128 + # fp128 ships default and D64 one-hot presets, plus D64 tensor and D128 # dense presets. "dense_fp128_d128": CaseMetadata("fp128", "dense", "dense", "D128"), "onehot_fp128_d64": CaseMetadata("fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64"), - "onehot_fp128_mixed_dim": CaseMetadata( + "onehot_fp128": CaseMetadata( "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "mixed D256 to D64" ), "onehot_fp128_d64_multi_group_recursive": CaseMetadata( @@ -159,7 +159,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", @@ -248,7 +248,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", diff --git a/specs/declarative-ring-dimension-policy.md b/specs/declarative-ring-dimension-policy.md index c8388e241..41db1f544 100644 --- a/specs/declarative-ring-dimension-policy.md +++ b/specs/declarative-ring-dimension-policy.md @@ -88,7 +88,7 @@ The implementation has the following shape: - Generated catalog identity stores the complete enum value and all three ordered adaptive capability lists. Challenge-hook identity covers every A candidate, including non-winners. -- `AdaptiveOneHot` uses two searched levels, a D64 uniform suffix, A +- `OneHot` uses two searched levels, a D64 uniform suffix, A candidates `[64, 128, 256]`, and B/D candidates `[64, 128]`. - Adaptive direct multi-chunk and recursive-setup planning remain rejected as specified. Scalar dispatch through a recursive adapter first applies its @@ -134,7 +134,7 @@ This revision makes the following decisions: 3. Keep dimension search bounded by configuration rather than planner constants. 4. Preserve canonical security sizing and verifier-visible schedule data. 5. Admit both D256 direct and D256 three-band paths naturally. -6. Keep planner logic independent of the concrete `AdaptiveOneHot` preset name. +6. Keep planner logic independent of the concrete `OneHot` preset name. 7. Preserve deterministic generation across machines and executions. ## Non-goals @@ -921,7 +921,7 @@ optional internal consolidation. `mixed_search.rs` may be removed only when: 3. the common frontier implements per-path preprocessing-first semantics; 4. uniform regressions remain unchanged where policy is unchanged; 5. adaptive selections agree with a bounded unpruned reference traversal; and -6. no planner branch refers to `AdaptiveOneHot` by name. +6. no planner branch refers to `OneHot` by name. Simply moving the current module's contents into another file is not consolidation. @@ -954,10 +954,10 @@ generated catalog Environment variables must not alter catalog-bound policy during proving or verification. -### Avoiding AdaptiveOneHot special-casing +### Avoiding OneHot special-casing The planner must dispatch on `RingDimensionScheduleMode`, not on the type name -`AdaptiveOneHot`. +`OneHot`. Whether the marker type remains temporarily as a concrete catalog/setup policy identity is a separate cleanup decision. The requirement is one canonical @@ -987,8 +987,8 @@ scripts/generate-schedule-tables.sh For the current native fp128 mixed family, the generated files are: ```text -fp128_mixed_dim_onehot.rs -fp128_mixed_dim_onehot_precommitted.rs +fp128_onehot.rs +fp128_onehot_precommitted.rs ``` Large generated `fp*.rs` family files are intentionally ignored by Git and @@ -998,7 +998,7 @@ feature-gated wiring and constructs the `GeneratedScheduleTable`. Generated rows are compact Rust static data. Runtime expansion reconstructs widths, SIS keys, and secure ranks through canonical primitives. -The current `fp128_mixed_dim_onehot` generated family contains only: +The current `fp128_onehot` generated family contains only: ```text nv = 32 @@ -1016,8 +1016,8 @@ The repository currently exercises mixed dimensions through distinct paths. | Experiment | Effective config | Schedule source | | ------------------------------------ | ------------------------------------------------------------------------------------ | ----------------------------------- | -| Stock `onehot_fp128_mixed_dim`, nv32 | `AdaptiveOneHot` | Generated runtime catalog | -| Planner diagnostic, nv18–nv40 | Policy derived from `AdaptiveOneHot` | Direct offline `find_schedule` call | +| Stock `onehot_fp128`, nv32 | `OneHot` | Generated runtime catalog | +| Planner diagnostic, nv18–nv40 | Policy derived from `OneHot` | Direct offline `find_schedule` call | | D256 direct timing profile | `MixedDConfig` | Synthetic test-support builder | | Historical D256 three-band profile | D256 root, uniform-D128 middle policy, D64 suffix | Synthetic test-support builder | @@ -1027,17 +1027,17 @@ The repository currently exercises mixed dimensions through distinct paths. The stock mode: ```text -AKITA_MODE=onehot_fp128_mixed_dim +AKITA_MODE=onehot_fp128 ``` -uses `fp128::AdaptiveOneHot`, fixes nv32, calls +uses `fp128::OneHot`, fixes nv32, calls `Cfg::runtime_schedule`, and gives that exact generated row to the PCS prover and verifier. ### Direct offline diagnostics The `mixed_dimension_search` example derives policy from -`AdaptiveOneHot` but calls the offline planner directly. The nv18, nv24, +`OneHot` but calls the offline planner directly. The nv18, nv24, nv32, nv36, and diagnostic over-cap nv40 results discussed in this design review came from this path and are not current runtime catalog rows. @@ -1215,7 +1215,7 @@ The first implementation is complete when: 256/128/128 -> 64/64/64 -> D64 256/128/128 -> 128/64/64 -> D64 ``` -10. Planner logic contains no branch keyed on `AdaptiveOneHot`. +10. Planner logic contains no branch keyed on `OneHot`. 11. Runtime remains generated-catalog-only. ## Remaining implementation questions diff --git a/specs/mixed-ring-dimension-per-level.md b/specs/mixed-ring-dimension-per-level.md index 6117d5181..3b868e0c5 100644 --- a/specs/mixed-ring-dimension-per-level.md +++ b/specs/mixed-ring-dimension-per-level.md @@ -7,7 +7,7 @@ | 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/` | diff --git a/specs/schedule-catalog-ownership.md b/specs/schedule-catalog-ownership.md index 514034dd3..2ae25328a 100644 --- a/specs/schedule-catalog-ownership.md +++ b/specs/schedule-catalog-ownership.md @@ -733,7 +733,7 @@ zk = ["akita-planner/zk", "akita-types/zk", "akita-schedules?/zk"] schedules-default = [ "schedules-fp128-d64-onehot", "schedules-fp128-d64-dense", - "schedules-fp128-mixed-dim-onehot", + "schedules-fp128-onehot", "schedules-fp128-d128-dense", "schedules-fp32-d128-onehot", "schedules-fp32-d256-onehot", diff --git a/specs/y-ring-trace-internalization.md b/specs/y-ring-trace-internalization.md index fa3ed74f7..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_mixed_dim 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 From f404c3a89f87a56ec44693c321546c2f22191ce1 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Thu, 6 Aug 2026 12:28:23 -0700 Subject: [PATCH 08/24] refactor(config): remove fp128 d128 dense preset --- book/src/usage/profiling.md | 8 +- book/src/usage/quickstart.md | 8 +- crates/akita-config/Cargo.toml | 2 - crates/akita-config/src/lib.rs | 13 +- .../akita-config/src/proof_optimized/fp128.rs | 44 ----- crates/akita-config/tests/generated_tables.rs | 6 - crates/akita-config/tests/runtime_fallback.rs | 1 - crates/akita-pcs/benches/akita_e2e.rs | 18 +- crates/akita-pcs/examples/profile/modes.rs | 19 --- crates/akita-pcs/tests/setup.rs | 10 -- crates/akita-pcs/tests/single_poly_e2e.rs | 20 +-- .../akita-planner/src/generated_families.rs | 17 -- .../akita-planner/src/test/schedule_params.rs | 4 +- .../evaluation_trace/tests.rs | 2 +- crates/akita-prover/tests/dispatch_dim.rs | 8 +- .../akita-prover/tests/orchestration_dim.rs | 4 +- crates/akita-schedules/Cargo.toml | 2 - .../src/generated/fp128_d128_dense.rs | 159 ------------------ .../fp128_d128_dense_precommitted.rs | 15 -- crates/akita-schedules/src/generated/mod.rs | 14 -- crates/akita-setup/src/lib.rs | 8 +- crates/akita-verifier/Cargo.toml | 1 - .../src/protocol/evaluation_trace.rs | 4 +- scripts/profile_bench_report.py | 6 +- specs/mixed-ring-dimension-per-level.md | 8 +- specs/profile-bench-coverage-matrix.md | 10 +- specs/schedule-catalog-ownership.md | 1 - 27 files changed, 56 insertions(+), 356 deletions(-) delete mode 100644 crates/akita-schedules/src/generated/fp128_d128_dense.rs delete mode 100644 crates/akita-schedules/src/generated/fp128_d128_dense_precommitted.rs diff --git a/book/src/usage/profiling.md b/book/src/usage/profiling.md index e24f3a78e..7a18a043a 100644 --- a/book/src/usage/profiling.md +++ b/book/src/usage/profiling.md @@ -31,15 +31,15 @@ The default direct **fp128** one-hot preset is adaptive: generated tables choose the first two fold levels and use D64 for the uniform suffix. The explicit uniform `fp128_d64_onehot` baseline remains available, and recursive presets remain D64. Shipped tables include `fp128_onehot`, -`fp128_d64_onehot`, `fp128_d64_dense`, and `fp128_d128_dense`. +`fp128_d64_onehot` and `fp128_d64_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`. +Compare one-hot schedules with +`akita_config::proof_optimized::fp128::best_onehot_schedule`. Dense fp128 uses +the single `D64Dense` runtime catalog. ## Environment knobs diff --git a/book/src/usage/quickstart.md b/book/src/usage/quickstart.md index 370996e66..d7401ca96 100644 --- a/book/src/usage/quickstart.md +++ b/book/src/usage/quickstart.md @@ -32,12 +32,12 @@ one-hot preset now chooses dimensions per fold from generated adaptive tables; | Field | Typical production choice | Notes | |-------|---------------------------|--------| -| **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. Explicit uniform `fp128::D64OneHot` remains available, and Jolt/recursive presets remain pinned to D64. Shipped tables include the default and D64 one-hot families plus D64/D128 dense. | +| **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. Explicit uniform `fp128::D64OneHot` remains available, and Jolt/recursive presets remain pinned to D64. Shipped tables include the default and D64 one-hot families plus D64 dense. | | **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 the available fp128 presets for a lookup key. -Every preset falls back to the verifier-reachable planner on table miss. +Use `akita_config::proof_optimized::fp128::best_onehot_schedule` to compare the +available fp128 one-hot presets for a lookup key. Dense fp128 uses +`fp128::D64Dense` directly. **Test harness vs profile defaults.** `crates/akita-pcs/tests/common/mod.rs` uses `fp128::D64OneHot` (one-hot) and `fp128::D64Dense` (dense tests); profile/CI diff --git a/crates/akita-config/Cargo.toml b/crates/akita-config/Cargo.toml index e338f68cc..5f0db8132 100644 --- a/crates/akita-config/Cargo.toml +++ b/crates/akita-config/Cargo.toml @@ -23,7 +23,6 @@ schedules-default = [ "schedules-fp128-d64-onehot", "schedules-fp128-onehot", "schedules-fp128-d64-dense", - "schedules-fp128-d128-dense", "schedules-fp32-d128-onehot", "schedules-fp32-d256-onehot", "schedules-fp64-d128-dense", @@ -49,7 +48,6 @@ schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2 = [ "akita-schedules/fp128-d64-onehot-recursive-multi-chunk-w8r2", ] schedules-fp128-d64-dense = ["akita-schedules/fp128-d64-dense"] -schedules-fp128-d128-dense = ["akita-schedules/fp128-d128-dense"] schedules-fp128-d64-onehot-tensor = ["akita-schedules/fp128-d64-onehot-tensor"] schedules-fp128-d64-onehot-multi-chunk = [ "akita-schedules/fp128-d64-onehot-multi-chunk", diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index e83a37fbd..84ea921b4 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -712,20 +712,17 @@ 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 dense = fp128::D64Dense::runtime_schedule(AkitaScheduleLookupKey::single(key)) + .expect("D64 dense schedule"); let onehot = fp128::best_onehot_schedule(key) .expect("selector should resolve onehot schedules") .expect("selector should find a generated onehot schedule"); - for selection in [&dense, &onehot] { - assert_eq!(selection.schedule.initial_witness_len(), 1usize << 32); - } - assert!(!dense.preset.is_onehot()); + assert_eq!(dense.initial_witness_len(), 1usize << 32); + assert_eq!(onehot.schedule.initial_witness_len(), 1usize << 32); assert!(onehot.preset.is_onehot()); } diff --git a/crates/akita-config/src/proof_optimized/fp128.rs b/crates/akita-config/src/proof_optimized/fp128.rs index 8dd88d1a6..6d622e5fd 100644 --- a/crates/akita-config/src/proof_optimized/fp128.rs +++ b/crates/akita-config/src/proof_optimized/fp128.rs @@ -6,10 +6,6 @@ use super::*; /// Base field for the default fp128 presets. pub type Field = Prime128OffsetA7F7; -/// Dense `D=128` preset for planner-backed experiments. -#[derive(Clone, Copy, Debug, Default)] -pub struct D128Dense; - /// Dense adaptive `D=64` preset. #[derive(Clone, Copy, Debug, Default)] pub struct D64Dense; @@ -67,21 +63,6 @@ pub struct D64OneHotMultiChunkW4R2; #[derive(Clone, Copy, Debug, Default)] pub struct D64DenseMultiChunk; -impl_proof_optimized_preset!( - D128Dense, - 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!( D64Dense, Field, @@ -194,9 +175,6 @@ impl_multi_chunk_companion!( 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 preset with adaptive per-level ring dimensions. @@ -208,7 +186,6 @@ impl Fp128Preset { pub const fn ring_dimension(self) -> usize { match self { Self::D64Dense | Self::D64OneHot => 64, - Self::D128Dense => 128, Self::OneHot => 256, } } @@ -222,7 +199,6 @@ impl Fp128Preset { pub const fn name(self) -> &'static str { match self { Self::D64Dense => "D64Dense", - Self::D128Dense => "D128Dense", Self::D64OneHot => "D64OneHot", Self::OneHot => "OneHot", } @@ -292,26 +268,6 @@ where }) } -/// 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 diff --git a/crates/akita-config/tests/generated_tables.rs b/crates/akita-config/tests/generated_tables.rs index 525ed43bc..7059cc862 100644 --- a/crates/akita-config/tests/generated_tables.rs +++ b/crates/akita-config/tests/generated_tables.rs @@ -72,7 +72,6 @@ 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_onehot" => fp128::OneHot::schedule_catalog().is_some(), "fp128_d64_onehot" => fp128::D64OneHot::schedule_catalog().is_some(), "fp128_d64_onehot_recursive" => { @@ -344,7 +343,6 @@ fn family_catalog( keys: &[PolynomialGroupLayout], ) -> akita_schedules::GeneratedScheduleTable { match family.module_name { - "fp128_d128_dense" => prepare_family_catalog::(family, keys), "fp128_onehot" => prepare_family_catalog::(family, keys), "fp128_d64_onehot" => prepare_family_catalog::(family, keys), "fp128_d64_onehot_recursive" => prepare_family_catalog::< @@ -402,9 +400,6 @@ 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) } @@ -497,7 +492,6 @@ fn resolve_family_group_batch_schedule( request: &GroupBatchCandidate, ) -> Result { match family.module_name { - "fp128_d128_dense" => table_backed_group_batch_schedule::(request), "fp128_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::< diff --git a/crates/akita-config/tests/runtime_fallback.rs b/crates/akita-config/tests/runtime_fallback.rs index 8e6e064a2..f5a5af213 100644 --- a/crates/akita-config/tests/runtime_fallback.rs +++ b/crates/akita-config/tests/runtime_fallback.rs @@ -388,7 +388,6 @@ 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::(); diff --git a/crates/akita-pcs/benches/akita_e2e.rs b/crates/akita-pcs/benches/akita_e2e.rs index 63f1ad5c5..8f28a2066 100644 --- a/crates/akita-pcs/benches/akita_e2e.rs +++ b/crates/akita-pcs/benches/akita_e2e.rs @@ -418,14 +418,14 @@ fn bench_onehot_phases(c, "dense-d128", 15); +fn bench_dense_nv14(c: &mut Criterion) { + bench_dense_phases::<{ fp128::D64Dense::D }, fp128::D64Dense>(c, "dense-d64", 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::D64Dense::D }, fp128::D64Dense>(c, "dense-d64", 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::D64Dense::D }, fp128::D64Dense>(c, "dense-d64", 24); } fn bench_onehot_nv15(c: &mut Criterion) { @@ -440,9 +440,9 @@ fn bench_onehot_nv25(c: &mut Criterion) { 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/examples/profile/modes.rs b/crates/akita-pcs/examples/profile/modes.rs index 8667bcb7a..6e822afc9 100644 --- a/crates/akita-pcs/examples/profile/modes.rs +++ b/crates/akita-pcs/examples/profile/modes.rs @@ -244,10 +244,6 @@ const PROFILE_ALL_MODES: &[ProfileMode] = &[ name: "onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2", run: run_profile_onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2, }, - ProfileMode { - name: "dense_fp128_d128", - run: run_profile_dense_fp128_d128, - }, ProfileMode { name: "onehot_fp128_d64_tensor", run: run_profile_onehot_fp128_d64_tensor, @@ -318,7 +314,6 @@ const EXCLUDED_FROM_ALL_SWEEP: &[&str] = &[ // 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", "dense_fp32_d128", "onehot_fp32_d128", "onehot_fp64_d128", @@ -538,20 +533,6 @@ fn run_profile_onehot_fp128_d64_tensor(nv: usize, num_polys: usize) { run_onehot_mode::<{ Cfg::D }, Cfg>("onehot_fp128_d64_tensor", &title, 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_fp32_d64(nv: usize, num_polys: usize) { type Cfg = fp32::D64OneHot; diff --git a/crates/akita-pcs/tests/setup.rs b/crates/akita-pcs/tests/setup.rs index beaa081d4..4425163ca 100644 --- a/crates/akita-pcs/tests/setup.rs +++ b/crates/akita-pcs/tests/setup.rs @@ -592,16 +592,6 @@ 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, diff --git a/crates/akita-pcs/tests/single_poly_e2e.rs b/crates/akita-pcs/tests/single_poly_e2e.rs index d5a3a772c..7bcd9a31e 100644 --- a/crates/akita-pcs/tests/single_poly_e2e.rs +++ b/crates/akita-pcs/tests/single_poly_e2e.rs @@ -6,12 +6,12 @@ //! Two polynomial representations are covered: //! //! * **One-hot** — `fp128::D64OneHot` (D = 64, K = 256). -//! * **Dense** — `fp128::D128Dense` (D = 128, arbitrary field coefficients). +//! * **Dense** — `fp128::D64Dense` (D = 64, arbitrary field coefficients). //! //! Variable counts: //! //! - one-hot: 12, 15, 20 -//! - dense: 13, 15, 18 +//! - dense: 14, 16, 24 #![allow(missing_docs)] @@ -111,10 +111,10 @@ fn run_single_onehot(nv: usize) { } // --------------------------------------------------------------------------- -// Dense helpers (D = 128) +// Dense helpers (D = 64) // --------------------------------------------------------------------------- -type DenseCfg = fp128::D128Dense; +type DenseCfg = fp128::D64Dense; const DENSE_D: usize = DenseCfg::D; fn run_single_dense(nv: usize) { @@ -254,18 +254,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] diff --git a/crates/akita-planner/src/generated_families.rs b/crates/akita-planner/src/generated_families.rs index fb7ffcb53..d015cd690 100644 --- a/crates/akita-planner/src/generated_families.rs +++ b/crates/akita-planner/src/generated_families.rs @@ -57,16 +57,6 @@ pub const DEFAULT_STANDALONE_PRECOMMIT_NUM_VARS: &[usize] = &[14, 15, 16]; /// Polynomial counts emitted for standalone frozen precommit descriptors. pub const DEFAULT_STANDALONE_PRECOMMIT_NUM_POLYNOMIALS: &[usize] = &[1, 2]; -const FP128_D128_DENSE_KEYS: &[PolynomialGroupLayout] = &[ - PolynomialGroupLayout::singleton(13), - PolynomialGroupLayout::singleton(15), - PolynomialGroupLayout::singleton(16), - PolynomialGroupLayout::new(16, 2), - PolynomialGroupLayout::singleton(18), - PolynomialGroupLayout::new(20, 2), - PolynomialGroupLayout::singleton(24), -]; - const FP128_D64_DENSE_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(14), PolynomialGroupLayout::singleton(16), @@ -720,13 +710,6 @@ 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_d64_onehot", diff --git a/crates/akita-planner/src/test/schedule_params.rs b/crates/akita-planner/src/test/schedule_params.rs index ba12a1fa2..e8d1a9197 100644 --- a/crates/akita-planner/src/test/schedule_params.rs +++ b/crates/akita-planner/src/test/schedule_params.rs @@ -678,9 +678,9 @@ 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::D128Dense}; + use akita_config::{policy_of, proof_optimized::fp128::D64Dense}; - let mut policy = policy_of::(); + let mut policy = policy_of::(); let domain = RingDimensionSearchDomain::uniform(256).unwrap(); policy.uniform_ring_dimension = 256; policy.ring_dimension_schedule_mode = crate::RingDimensionScheduleMode::UniformDimension { 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..ba443aa47 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::D64Dense; type F = fp128::Field; const D: usize = Cfg::D; const NUM_VARIABLES: usize = 16; diff --git a/crates/akita-prover/tests/dispatch_dim.rs b/crates/akita-prover/tests/dispatch_dim.rs index 78b3fc051..5f391358c 100644 --- a/crates/akita-prover/tests/dispatch_dim.rs +++ b/crates/akita-prover/tests/dispatch_dim.rs @@ -41,8 +41,8 @@ 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_d64_schedule() { + let schedule = schedule::(16); + validate_schedule_ring_dims(&schedule).expect("D64 schedule"); + assert_schedule_geometry(&schedule, 64); } diff --git a/crates/akita-prover/tests/orchestration_dim.rs b/crates/akita-prover/tests/orchestration_dim.rs index 47b1ecb20..1558a2e11 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::D64Dense::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] diff --git a/crates/akita-schedules/Cargo.toml b/crates/akita-schedules/Cargo.toml index 28e1bdd27..8660a29dc 100644 --- a/crates/akita-schedules/Cargo.toml +++ b/crates/akita-schedules/Cargo.toml @@ -31,7 +31,6 @@ schedules-default = [ "fp128-d64-onehot", "fp128-onehot", "fp128-d64-dense", - "fp128-d128-dense", "fp32-d128-onehot", "fp32-d256-onehot", "fp64-d128-dense", @@ -43,7 +42,6 @@ fp128-onehot = [] fp128-d64-onehot-recursive = [] fp128-d64-onehot-recursive-multi-chunk-w8r2 = [] fp128-d64-dense = [] -fp128-d128-dense = [] fp128-d64-onehot-tensor = [] fp128-d64-onehot-multi-chunk = [] fp128-d64-onehot-multi-chunk-w2r2 = [] 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 14549411f..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, GeneratedRootFinalChallenge, - GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, - GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, - GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, -}; - -#[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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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_DIMENSIONS: &[usize] = &[128]; -#[rustfmt::skip] -pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d128_dense", - protocol_epoch: 3, - 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, - root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 128 }, - 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/mod.rs b/crates/akita-schedules/src/generated/mod.rs index d7ce7b816..290b71548 100644 --- a/crates/akita-schedules/src/generated/mod.rs +++ b/crates/akita-schedules/src/generated/mod.rs @@ -457,10 +457,6 @@ 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-d64-dense")] pub mod fp128_d64_dense; #[cfg(feature = "fp128-d64-dense-multi-chunk")] @@ -522,16 +518,6 @@ 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 { - GeneratedScheduleTable { - entries: fp128_d128_dense::FP128_D128_DENSE_SCHEDULES, - precommitted_profiles: - fp128_d128_dense_precommitted::FP128_D128_DENSE_SCHEDULES_PRECOMMITTED_PROFILES, - identity: fp128_d128_dense::CATALOG_IDENTITY, - } -} - #[cfg(feature = "fp128-d64-dense")] pub fn fp128_d64_dense_table() -> GeneratedScheduleTable { GeneratedScheduleTable { diff --git a/crates/akita-setup/src/lib.rs b/crates/akita-setup/src/lib.rs index 8635c62da..c4a5de7fc 100644 --- a/crates/akita-setup/src/lib.rs +++ b/crates/akita-setup/src/lib.rs @@ -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"); + // The D64 catalog begins at nv=14, the first singleton shape with the + // required root and suffix folds. new_prover_setup::(14, 1) - .expect("small-D fp128 preset should accept the default field"); + .expect("fp128 dense preset should accept the default field"); } #[cfg(feature = "disk-persistence")] diff --git a/crates/akita-verifier/Cargo.toml b/crates/akita-verifier/Cargo.toml index d804f54e8..c58262fcf 100644 --- a/crates/akita-verifier/Cargo.toml +++ b/crates/akita-verifier/Cargo.toml @@ -42,7 +42,6 @@ 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", ] } criterion = "0.5" diff --git a/crates/akita-verifier/src/protocol/evaluation_trace.rs b/crates/akita-verifier/src/protocol/evaluation_trace.rs index 505de7707..d7fd19c2f 100644 --- a/crates/akita-verifier/src/protocol/evaluation_trace.rs +++ b/crates/akita-verifier/src/protocol/evaluation_trace.rs @@ -335,11 +335,11 @@ mod tests { #[test] fn compact_trace_matches_dense_definition_across_coefficient_blocks() { - type Cfg = fp128::D128Dense; + type Cfg = fp128::D64Dense; 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/scripts/profile_bench_report.py b/scripts/profile_bench_report.py index 783b5abfb..0b585ce18 100644 --- a/scripts/profile_bench_report.py +++ b/scripts/profile_bench_report.py @@ -88,9 +88,7 @@ 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 default and D64 one-hot presets, plus D64 tensor and D128 - # dense presets. - "dense_fp128_d128": CaseMetadata("fp128", "dense", "dense", "D128"), + # fp128 ships default and D64 one-hot presets, plus D64 tensor and dense. "onehot_fp128_d64": CaseMetadata("fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64"), "onehot_fp128": CaseMetadata( "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "mixed D256 to D64" @@ -2132,7 +2130,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/specs/mixed-ring-dimension-per-level.md b/specs/mixed-ring-dimension-per-level.md index 3b868e0c5..a7bec5da6 100644 --- a/specs/mixed-ring-dimension-per-level.md +++ b/specs/mixed-ring-dimension-per-level.md @@ -262,10 +262,10 @@ The shipped selection policies are: | `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. +selection. The fp128 `best_onehot_schedule` helper compares the separately +generated uniform-D64 and default per-level catalogs by proof bytes, then uses +the smaller setup-generation dimension as a tie-break. It is a family selector +outside the schedule DP and does not run a new search. ### Current search algorithm diff --git a/specs/profile-bench-coverage-matrix.md b/specs/profile-bench-coverage-matrix.md index 7d8418f9b..34ce72bd4 100644 --- a/specs/profile-bench-coverage-matrix.md +++ b/specs/profile-bench-coverage-matrix.md @@ -78,11 +78,11 @@ The ring degree differs by field, for two distinct reasons: 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 + and by the `best_onehot_schedule` selector, 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. + `best_onehot_schedule` to compare supported one-hot families. D32/D128 profile modes still exist for direct local comparisons, but neither the adaptive `full`/`onehot` selectors nor those comparison modes are part of @@ -193,7 +193,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 @@ -283,7 +283,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 @@ -441,8 +441,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/schedule-catalog-ownership.md b/specs/schedule-catalog-ownership.md index 2ae25328a..b13a4bdaa 100644 --- a/specs/schedule-catalog-ownership.md +++ b/specs/schedule-catalog-ownership.md @@ -734,7 +734,6 @@ schedules-default = [ "schedules-fp128-d64-onehot", "schedules-fp128-d64-dense", "schedules-fp128-onehot", - "schedules-fp128-d128-dense", "schedules-fp32-d128-onehot", "schedules-fp32-d256-onehot", "schedules-fp64-d128-onehot", From 308ebc8142f2961849dda8aa07398859a6242142 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Thu, 6 Aug 2026 14:23:50 -0700 Subject: [PATCH 09/24] feat(config): add adaptive fp128 dense schedules --- PR_DESCRIPTION.md | 204 +++ crates/akita-config/Cargo.toml | 2 + crates/akita-config/src/lib.rs | 19 + .../akita-config/src/proof_optimized/fp128.rs | 36 +- crates/akita-config/tests/generated_tables.rs | 6 + .../akita-planner/src/generated_families.rs | 33 + crates/akita-schedules/Cargo.toml | 2 + .../src/generated/fp128_dense.rs | 227 +++ .../src/generated/fp128_dense_precommitted.rs | 15 + crates/akita-schedules/src/generated/mod.rs | 14 + specs/declarative-ring-dimension-policy.md | 1235 ----------------- 11 files changed, 556 insertions(+), 1237 deletions(-) create mode 100644 PR_DESCRIPTION.md create mode 100644 crates/akita-schedules/src/generated/fp128_dense.rs create mode 100644 crates/akita-schedules/src/generated/fp128_dense_precommitted.rs delete mode 100644 specs/declarative-ring-dimension-policy.md diff --git a/PR_DESCRIPTION.md b/PR_DESCRIPTION.md new file mode 100644 index 000000000..cfa19ba51 --- /dev/null +++ b/PR_DESCRIPTION.md @@ -0,0 +1,204 @@ +# Adaptive ring dimensions for fp128 one-hot + +## Summary + +This PR makes adaptive ring dimensions the default configuration for direct fp128 one-hot and dense commitments. + +Instead of selecting a fixed ring dimension for the entire protocol, the offline planner searches the leading fold levels and selects ring dimensions independently for commitment matrices A, B, and D. Later folds use a uniform D64 suffix. + +The selected schedules are generated ahead of time and stored in the schedule catalog. Proving and verification only load and validate the generated row; they do not run the planner. + +## What changed + +### Declarative ring-dimension policy + +`CommitmentConfig` now describes its ring-dimension behavior using: + +```rust +RingDimensionScheduleMode +``` + +with two variants: + +```rust +UniformDimension { + ring_dimension, +} + +AdaptiveDimension { + num_search_levels, + uniform_suffix_dimension, + potential_a_dimensions, + potential_b_dimensions, + potential_d_dimensions, +} +``` + +Uniform configurations retain the existing single-dimension planner path. + +Adaptive configurations use a bounded offline search over the configured dimensions and fold levels. + +### Adaptive planner + +For the fp128 one-hot configuration, the planner: + +- Searches ring dimensions at L0 and L1. +- Uses D64 uniformly from L2 through the terminal fold. +- Searches A dimensions from `[64, 128, 256]`. +- Derives B and D from `[64, 128]`. +- Requires A dimensions to be non-increasing across searched levels. +- Allows adjacent A dimensions to be equal. +- Computes the exact secure rank for each matrix candidate. + +A is the branching search dimension. B and D do not introduce additional planner branches. For each selected A geometry, the planner scans their allowed dimensions and selects the dimension with the smallest secure rank: + +- Stop increasing the dimension once rank 1 is reached. +- If rank 1 is unavailable, retain the dimension producing the smallest rank. +- Prefer the smaller dimension when two dimensions produce the same rank. + +Complete schedules are selected using the following ordering: + +1. A rank and A dimension at each searched level. +2. Physical preprocessing-matrix footprint. +3. Estimated proof size. +4. Canonical schedule descriptor bytes as the deterministic tie-break. + +This allows larger dimensions when they materially reduce rank without requiring rank 1 in every case. + +### Default fp128 one-hot configuration + +`fp128::OneHot` is now the canonical direct fp128 one-hot preset. + +It uses: + +```text +Setup-generation dimension: D256 +Adaptive levels: L0 and L1 +A candidates: D64, D128, D256 +B candidates: D64, D128 +D candidates: D64, D128 +Uniform suffix: D64 +``` + +For the generated `nv = 36` row, the resulting dimensions are: + +```text +L0: A/B/D = 256/128/128 +L1: A/B/D = 256/64/64 +L2+: A/B/D = 64/64/64 +Terminal: D64 +``` + +The generated table currently contains direct one-hot rows for `nv = 32` and `nv = 36`. + +The explicit uniform `fp128::D64OneHot` preset remains available as a baseline. + +### Default fp128 dense configuration + +`fp128::Dense` is the canonical adaptive dense preset. It uses the same D256 +setup-generation envelope, two searched leading levels, candidate dimensions, +and uniform D64 suffix as `fp128::OneHot`, while retaining the dense coefficient +bounds and honest-fold policy. + +The generated `fp128_dense` catalog covers the existing fp128 dense scalar and +batched key set. `fp128_dense_precommitted` stores the corresponding standalone +precommitted descriptors. The explicit uniform `fp128::D64Dense` preset and its +catalog remain available as a baseline and for existing multi-chunk paths. + +### Generated catalog identity + +Generated schedule identity now includes the complete `RingDimensionScheduleMode`, including: + +- Number of adaptive levels. +- Uniform suffix dimension. +- Ordered A candidate dimensions. +- Ordered B candidate dimensions. +- Ordered D candidate dimensions. + +Catalog validation checks that: + +- Every generated fold uses dimensions admitted by the policy. +- A dimensions are non-increasing across adaptive levels. +- The uniform suffix begins at the configured level. +- The terminal uses the configured suffix dimension. +- Every potential A dimension is covered by the challenge-configuration identity. +- Policy changes invalidate stale generated tables. + +Runtime proving and verification remain catalog-only. A missing row is rejected rather than falling back to planner execution. + +### Configuration and catalog cleanup + +Because adaptive one-hot is now the default fp128 configuration, this PR removes redundant fp128 catalogs and presets: + +- D128 one-hot +- D128 one-hot precommitted +- D256 one-hot generated catalog +- D256 one-hot precommitted catalog +- D128 dense +- D128 dense precommitted + +The tableless `D256OneHot` marker remains available for experiments that need a fixed D256 configuration, but it no longer has a shipped runtime catalog. + +The previous `fp128_mixed_dim_onehot` naming has also been removed. The canonical generated family is now simply: + +```text +fp128_onehot +``` + +and the corresponding profiling mode remains: + +```text +onehot_fp128 +``` + +### Profiling and CI + +Profiling documentation, feature selection, benchmark dispatch, and CI coverage have been updated for the canonical adaptive fp128 one-hot family. + +The profiler reports the actual A/B/D dimensions and matrix ranks selected at each fold, making adaptive schedule choices directly observable. + +## Scope and limitations + +This PR supports adaptive dimensions for direct fp128 one-hot and dense schedules. + +The following paths remain on their existing uniform-D configurations: + +- fp32 and fp64 presets +- recursive setup offloading +- distributed/multi-chunk proving +- heterogeneous multi-group roots + +In particular, adaptive dimensions and recursive setup offloading are not yet combined. Recursive and distributed fp128 one-hot configurations continue to use their existing D64 catalogs. + +## Compatibility + +This is an intentional breaking configuration and generated-catalog change. + +Users of the old fp128 D128/D256 one-hot generated families or the `fp128_mixed_dim_onehot` names should migrate to: + +```rust +akita_config::proof_optimized::fp128::OneHot +``` + +Use `fp128::D64OneHot` when an explicitly uniform D64 direct schedule is required. + +## Validation + +The implementation includes coverage for: + +- Adaptive policy validation. +- A-dimension monotonicity. +- Independent B/D rank minimization. +- Rank greater than one when no candidate reaches rank one. +- Uniform suffix enforcement. +- Generated-row expansion and replay. +- Catalog identity drift. +- Planner/generated schedule parity. +- Deterministic candidate selection. +- Honest proving and verification. +- Wrong openings and commitment/proof tampering. +- Malformed or unsupported dimensions. +- Setup-capacity validation. +- Preservation of existing uniform planner paths. + +Documentation guardrails and generated-catalog consistency checks pass. diff --git a/crates/akita-config/Cargo.toml b/crates/akita-config/Cargo.toml index 5f0db8132..890fc908d 100644 --- a/crates/akita-config/Cargo.toml +++ b/crates/akita-config/Cargo.toml @@ -22,6 +22,7 @@ test-support = [] schedules-default = [ "schedules-fp128-d64-onehot", "schedules-fp128-onehot", + "schedules-fp128-dense", "schedules-fp128-d64-dense", "schedules-fp32-d128-onehot", "schedules-fp32-d256-onehot", @@ -41,6 +42,7 @@ all-schedules = [ ] schedules-fp128-d64-onehot = ["akita-schedules/fp128-d64-onehot"] schedules-fp128-onehot = ["akita-schedules/fp128-onehot"] +schedules-fp128-dense = ["akita-schedules/fp128-dense"] schedules-fp128-d64-onehot-recursive = [ "akita-schedules/fp128-d64-onehot-recursive", ] diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index 84ea921b4..fbb625a24 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -672,6 +672,20 @@ mod fp128_policy_tests { assert!(fp128::D256OneHot::schedule_catalog().is_none()); } + #[test] + 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_d64_dense_schedule_stays_within_audited_sis_widths() { assert_cfg_schedule_stays_within_audited_sis_widths::( @@ -679,6 +693,11 @@ mod fp128_policy_tests { ); } + #[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_d64_onehot_schedule_stays_within_audited_sis_widths() { assert_cfg_schedule_stays_within_audited_sis_widths::( diff --git a/crates/akita-config/src/proof_optimized/fp128.rs b/crates/akita-config/src/proof_optimized/fp128.rs index 6d622e5fd..e871713fa 100644 --- a/crates/akita-config/src/proof_optimized/fp128.rs +++ b/crates/akita-config/src/proof_optimized/fp128.rs @@ -10,6 +10,17 @@ pub type Field = Prime128OffsetA7F7; #[derive(Clone, Copy, Debug, Default)] pub struct D64Dense; +/// Default dense preset with D256 setup generation and planner-selected +/// per-level commitment dimensions. +#[derive(Clone, Copy, Debug, Default)] +pub struct Dense; + +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 generated `D=64` preset. #[derive(Clone, Copy, Debug, Default)] pub struct D64OneHot; @@ -78,6 +89,24 @@ impl_proof_optimized_preset!( fp128_d64_dense_table ) ); +impl_proof_optimized_preset!( + Dense, + Field, + Field, + akita_types::SisModulusProfileId::Q128OffsetA7F7, + 256, + 128, + 128, + fold_norms = akita_types::sis::FoldWitnessNorms::bounded(3, 64), + schedules = ("schedules-fp128-dense", "fp128_dense", fp128_dense_table), + ring_dimension_schedule_mode = akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { + num_search_levels: 2, + 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!( D64OneHot, Field, @@ -173,8 +202,10 @@ impl_multi_chunk_companion!( /// Concrete fp128 preset selected by a schedule-family query. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Fp128Preset { - /// Dense adaptive `D=64` preset. + /// Dense uniform `D=64` preset. D64Dense, + /// Dense preset with adaptive per-level ring dimensions. + Dense, /// Binary onehot generated `D=64` preset. D64OneHot, /// Binary onehot preset with adaptive per-level ring dimensions. @@ -186,7 +217,7 @@ impl Fp128Preset { pub const fn ring_dimension(self) -> usize { match self { Self::D64Dense | Self::D64OneHot => 64, - Self::OneHot => 256, + Self::Dense | Self::OneHot => 256, } } @@ -199,6 +230,7 @@ impl Fp128Preset { pub const fn name(self) -> &'static str { match self { Self::D64Dense => "D64Dense", + Self::Dense => "Dense", Self::D64OneHot => "D64OneHot", Self::OneHot => "OneHot", } diff --git a/crates/akita-config/tests/generated_tables.rs b/crates/akita-config/tests/generated_tables.rs index 7059cc862..eacb07a56 100644 --- a/crates/akita-config/tests/generated_tables.rs +++ b/crates/akita-config/tests/generated_tables.rs @@ -73,6 +73,7 @@ fn group_batch_emission_matches_supported_policy_shape() { fn family_catalog_is_linked(family: &GeneratedFamily) -> bool { match family.module_name { "fp128_onehot" => fp128::OneHot::schedule_catalog().is_some(), + "fp128_dense" => fp128::Dense::schedule_catalog().is_some(), "fp128_d64_onehot" => fp128::D64OneHot::schedule_catalog().is_some(), "fp128_d64_onehot_recursive" => { as CommitmentConfig>::schedule_catalog() @@ -344,6 +345,7 @@ fn family_catalog( ) -> akita_schedules::GeneratedScheduleTable { match family.module_name { "fp128_onehot" => prepare_family_catalog::(family, keys), + "fp128_dense" => prepare_family_catalog::(family, keys), "fp128_d64_onehot" => prepare_family_catalog::(family, keys), "fp128_d64_onehot_recursive" => prepare_family_catalog::< akita_config::RecursiveCommitmentConfig, @@ -403,6 +405,9 @@ fn assert_family_group_batch_table_hit(family: &GeneratedFamily, requests: &[Gro "fp128_onehot" => { assert_group_batch_table_hits::(family.module_name, requests) } + "fp128_dense" => { + assert_group_batch_table_hits::(family.module_name, requests) + } "fp128_d64_onehot" => { assert_group_batch_table_hits::(family.module_name, requests) } @@ -493,6 +498,7 @@ fn resolve_family_group_batch_schedule( ) -> Result { match family.module_name { "fp128_onehot" => table_backed_group_batch_schedule::(request), + "fp128_dense" => 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, diff --git a/crates/akita-planner/src/generated_families.rs b/crates/akita-planner/src/generated_families.rs index d015cd690..6a6734689 100644 --- a/crates/akita-planner/src/generated_families.rs +++ b/crates/akita-planner/src/generated_families.rs @@ -70,6 +70,8 @@ const FP128_D64_DENSE_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(50), ]; +const FP128_DENSE_KEYS: &[PolynomialGroupLayout] = FP128_D64_DENSE_KEYS; + const FP128_D64_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(10), PolynomialGroupLayout::singleton(12), @@ -248,6 +250,20 @@ fn regen_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, + Cfg::fold_challenge_shape_at_level, + )? + .schedule) +} + /// Pure multi-group DP regeneration for `Cfg` — never consults the generated table. fn regen_group_batch( key: AkitaScheduleLookupKey, @@ -763,6 +779,23 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ FP128_D64_DENSE_KEYS, fp128::D64Dense ), + 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, + fold_challenge_shape_at_level: + ::fold_challenge_shape_at_level, + precommitted_profiles: precommitted_profiles::, + explicit_precommitted_group: explicit_precommitted_group::, + }, family_row!( group_batch, "fp128_d64_onehot_tensor", diff --git a/crates/akita-schedules/Cargo.toml b/crates/akita-schedules/Cargo.toml index 8660a29dc..7b4b09d08 100644 --- a/crates/akita-schedules/Cargo.toml +++ b/crates/akita-schedules/Cargo.toml @@ -30,6 +30,7 @@ all-schedules = [ schedules-default = [ "fp128-d64-onehot", "fp128-onehot", + "fp128-dense", "fp128-d64-dense", "fp32-d128-onehot", "fp32-d256-onehot", @@ -39,6 +40,7 @@ schedules-default = [ ] fp128-d64-onehot = [] fp128-onehot = [] +fp128-dense = [] fp128-d64-onehot-recursive = [] fp128-d64-onehot-recursive-multi-chunk-w8r2 = [] fp128-d64-dense = [] diff --git a/crates/akita-schedules/src/generated/fp128_dense.rs b/crates/akita-schedules/src/generated/fp128_dense.rs new file mode 100644 index 000000000..c753fce86 --- /dev/null +++ b/crates/akita-schedules/src/generated/fp128_dense.rs @@ -0,0 +1,227 @@ +// 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, GeneratedRootFinalChallenge, + GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, + GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, + GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, + PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, + SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, +}; + +#[rustfmt::skip] +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: 3, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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: 3, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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: 3, challenge: GeneratedRootFinalChallenge::Flat, + 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: 5700, positions_per_block: 256, live_blocks: 23 }, 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: 6653, 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(17, 4), num_digits_inner: 43, num_digits_fold: 4, challenge: GeneratedRootFinalChallenge::Flat, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 512, positions_per_block: 32, 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: 13999, positions_per_block: 512, live_blocks: 28 }, 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: 18607, 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::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(24, 1), num_digits_inner: 43, num_digits_fold: 4, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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, challenge: GeneratedRootFinalChallenge::Flat, + 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: 704794, positions_per_block: 2048, live_blocks: 345 }, 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: 211743, 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 }, + ], + 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: 43, num_digits_fold: 5, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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: 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 }, + ], + 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: 43, num_digits_fold: 6, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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: 112722288, positions_per_block: 65536, live_blocks: 1721 }, 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: 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: 2199882, positions_per_block: 16384, live_blocks: 135 }, 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: 101063, 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::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(50, 1), num_digits_inner: 43, num_digits_fold: 6, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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: 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 }, + ], + 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_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, 128, 256]; +#[rustfmt::skip] +pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { + family_name: "fp128_dense", + protocol_epoch: 3, + cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, + selection_policy: SelectionPolicyId::MinAdaptiveARankDimensionThenSetupAndProof, + 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: 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, + root_fold_shape: TensorChallengeShape::Flat, + 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: 3458533356553718245, + key_count: 10, + key_digest: 10902553869371788854, +}; diff --git a/crates/akita-schedules/src/generated/fp128_dense_precommitted.rs b/crates/akita-schedules/src/generated/fp128_dense_precommitted.rs new file mode 100644 index 000000000..8ff9c43c2 --- /dev/null +++ b/crates/akita-schedules/src/generated/fp128_dense_precommitted.rs @@ -0,0 +1,15 @@ +// 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_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: 64, 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: 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 }, + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), 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 }, + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), 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 } }, 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(16, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 64, 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/mod.rs b/crates/akita-schedules/src/generated/mod.rs index 290b71548..28c29d124 100644 --- a/crates/akita-schedules/src/generated/mod.rs +++ b/crates/akita-schedules/src/generated/mod.rs @@ -493,6 +493,10 @@ pub mod fp128_d64_onehot_recursive_precommitted; pub mod fp128_d64_onehot_tensor; #[cfg(feature = "fp128-d64-onehot-tensor")] pub mod fp128_d64_onehot_tensor_precommitted; +#[cfg(feature = "fp128-dense")] +pub mod fp128_dense; +#[cfg(feature = "fp128-dense")] +pub mod fp128_dense_precommitted; #[cfg(feature = "fp128-onehot")] pub mod fp128_onehot; #[cfg(feature = "fp128-onehot")] @@ -601,6 +605,16 @@ pub fn fp128_d64_onehot_tensor_table() -> GeneratedScheduleTable { } } +#[cfg(feature = "fp128-dense")] +pub fn fp128_dense_table() -> GeneratedScheduleTable { + GeneratedScheduleTable { + entries: fp128_dense::FP128_DENSE_SCHEDULES, + precommitted_profiles: + fp128_dense_precommitted::FP128_DENSE_SCHEDULES_PRECOMMITTED_PROFILES, + identity: fp128_dense::CATALOG_IDENTITY, + } +} + #[cfg(feature = "fp128-onehot")] pub fn fp128_onehot_table() -> GeneratedScheduleTable { GeneratedScheduleTable { diff --git a/specs/declarative-ring-dimension-policy.md b/specs/declarative-ring-dimension-policy.md deleted file mode 100644 index 41db1f544..000000000 --- a/specs/declarative-ring-dimension-policy.md +++ /dev/null @@ -1,1235 +0,0 @@ -# Declarative Ring-Dimension Schedule Policy - - -| Field | Value | -| ---------------------- | ------------------------------------------------------------------------------------------- | -| Status | Implemented | -| Revised | 2026-08-05 | -| Scope | Offline ring-dimension search, generated-catalog identity, and runtime replay | -| Related spec | `[mixed-ring-dimension-per-level.md](mixed-ring-dimension-per-level.md)` | -| Planner implementation | `[crates/akita-planner/src/schedule_params/](../crates/akita-planner/src/schedule_params/)` | -| Configuration bridge | `[crates/akita-config/src/lib.rs](../crates/akita-config/src/lib.rs)` | - - -## Summary - -Akita represents ring-dimension behavior with one declarative enum: - -```text -RingDimensionScheduleMode = - UniformDimension - | AdaptiveDimension -``` - -`UniformDimension` uses one uniform ring dimension for A, B, and D at every -fold and at the terminal. - -`AdaptiveDimension` performs a bounded brute-force search over potential A-ring -dimensions at a configured number of leading fold levels. A dimensions must -be non-increasing between adjacent searched levels. Each complete A-dimension -path first receives its best preprocessing/proof geometry. The planner then -selects the path lexicographically by `(minimum secure A rank, A dimension)` at -each searched level: a strict rank reduction justifies increasing dimension, -rank one stops further growth, and an equal rank keeps the smaller dimension. -If no dimension reaches rank one, the smallest rank found remains valid. From -the end of the configured search window onward, every role uses one fixed -uniform suffix dimension. - -B and D dimensions are not branching planner choices. Once an A dimension, -block geometry, basis, and role-native width are known, the planner scans the -ordered supported dimensions for that role from smallest to largest. It keeps -trying larger dimensions while deriving the exact secure rank, stops early if -rank one is reached, and otherwise selects the dimension with the smallest rank -found. A B- or D-role rank greater than one is valid when the allowed role -dimensions cannot reduce it further. Equal-rank choices prefer the smaller -dimension. - -The planner evaluates all valid A-dimension paths within the bounded search -window, derives B/D and all matrix ranks canonically, and plans the complete -uniform suffix. It first selects the best complete geometry for each exact A -path by physical preprocessing fields, modeled proof bytes, and descriptor -bytes. It then compares those path representatives by the per-level A -rank/dimension rule above. - -With two searched levels, potential A dimensions including D64, D128, and D256, -and a uniform-D64 suffix, the search includes: - -```text -256/128/128 -> 64/64/64 -> uniform D64 suffix - -256/128/128 -> 128/64/64 -> uniform D64 suffix - -256/128/128 -> 256/64/64 -> uniform D64 suffix -``` - -The first path is the D256 direct transition, the second is the D256 -three-band transition, and the third retains D256 for A at L1. None needs to -be passed as an explicit topology. - -The policy is implemented in the runtime policy, offline planner, catalog -identity, generated-table emitter, and the fp128 one-hot adaptive preset. - -## Implementation status - -The implementation has the following shape: - -- `CommitmentConfig::RING_DIMENSION_SCHEDULE_MODE` is the single configuration - input. The former tuple-valued config field and separate public search-domain - object are removed. -- `find_schedule` dispatches from the enum. Uniform policies reuse the existing - uniform suffix DP. Adaptive policies run the bounded leading-level frontier - and then rejoin the uniform suffix derivation. -- Root and recursive candidate construction share one - `RingDimensionCandidate` implementation. It fixes A for a search branch and - derives B/D from the canonical projected width and SIS table. -- Complete schedules are grouped by their exact A-dimension path. Setup/proof - scoring chooses one representative per path before representatives are - compared by per-level A rank and dimension. -- Generated catalog identity stores the complete enum value and all three - ordered adaptive capability lists. Challenge-hook identity covers every A - candidate, including non-winners. -- `OneHot` uses two searched levels, a D64 uniform suffix, A - candidates `[64, 128, 256]`, and B/D candidates `[64, 128]`. -- Adaptive direct multi-chunk and recursive-setup planning remain rejected as - specified. Scalar dispatch through a recursive adapter first applies its - direct-only policy and is therefore supported. - -The adaptive orchestration remains in `mixed_search.rs`, but it is no longer a -second public configuration/search API and contains no preset-name dispatch. -Its matrix construction, SIS pricing, setup accounting, proof pricing, and -materialization all call the same canonical primitives as uniform planning. -An unpruned adaptive traversal remains test-only and checks that frontier -pruning selects the same descriptor and estimate. - -## Decisions - -This revision makes the following decisions: - -1. Use `RingDimensionScheduleMode` with exactly two modes: - `UniformDimension` and `AdaptiveDimension`. -2. Brute-force A dimensions only. -3. Restrict A brute force to an explicit number of leading levels. -4. Require A to be smaller than or equal to the preceding A dimension between - adjacent searched levels. -5. Use a configured uniform suffix dimension after the search window. -6. Do not branch over B or D dimensions. -7. Derive B and D independently by scanning supported dimensions from smallest - to largest and minimizing exact secure rank. -8. Stop a B/D scan early at rank one; if no rank-one dimension exists, retain - the dimension with the lowest rank found, preferring the smaller dimension - on a rank tie. -9. For each exact A-dimension path, select its complete schedule by physical - preprocessing matrix fields, then proof bytes, then descriptor bytes. -10. Select among those path representatives by the lexicographic per-level - `(A rank, A dimension)` vector. Rank one is an early stop; if it is - unavailable, the smallest rank wins. -11. Keep all planner work offline and runtime schedule selection catalog-only. - -## Goals - -1. Find the smallest secure A rank over a small, explicit dimension domain - without sacrificing the best geometry available to each dimension path. -2. Avoid the much larger Cartesian search over A, B, D, and cross-level role - tuples. -3. Keep dimension search bounded by configuration rather than planner constants. -4. Preserve canonical security sizing and verifier-visible schedule data. -5. Admit both D256 direct and D256 three-band paths naturally. -6. Keep planner logic independent of the concrete `OneHot` preset name. -7. Preserve deterministic generation across machines and executions. - -## Non-goals - -- The planner does not brute-force B dimensions. -- The planner does not brute-force D dimensions. -- The planner does not search adaptive dimensions after the configured level -window. -- The planner does not reject an A path merely because no allowed dimension - reaches rank one. -- The planner does not optimize measured commit, prove, or verify wall time. -- Runtime proving and verification do not invoke the planner. -- Uniform D512 B/D commitments are not made valid by this policy. -- Mixed recursive-setup and mixed multi-chunk planning are not automatically -enabled. - -## Terminology and dimensions - -### Setup-generation dimension - -The setup-generation dimension is the ring dimension used to derive and store -the shared preprocessing matrix. It is currently represented by -`CommitmentConfig::D`. - -It is separate from the role dimensions used by a particular fold. Every -role-local ring dimension must divide the setup-generation dimension. - -For example, a D256 setup may support D256, D128, and D64 role views, but it -cannot support a D512 role. - -### Commitment-role dimensions - -Every non-terminal fold has three dimensions: - -```text -d_a: inner A matrix, fold arithmetic, and A-native source ring -d_b: outer B matrix -d_d: opening D matrix -``` - -They are represented as: - -```text -CommitmentRingDims { - inner: d_a, - outer: d_b, - opening: d_d, -} -``` - -The A-native source is projected into B and D. Each selected tuple must satisfy: - -```text -d_b <= d_a -d_d <= d_a -d_a % d_b == 0 -d_a % d_d == 0 -``` - -B and D are selected independently. Neither role is ordered relative to the -other. - -### Searched level - -A searched level is a leading fold level at which the planner enumerates -potential A dimensions. - -If `num_search_levels = 2`, the search applies only to: - -```text -L0 and L1 -``` - -L2 and every later fold use the uniform suffix dimension. - -The terminal always uses the uniform suffix dimension. - -### Uniform suffix - -The uniform suffix begins at `num_search_levels`: - -```text -first_uniform_level = num_search_levels -``` - -For example: - -```text -num_search_levels = 2 -uniform_suffix_dimension = 64 - -L0: search A -L1: search the same or a smaller A -L2+: A/B/D = 64/64/64 -terminal: D64 -``` - -The suffix may equal the A dimension selected at the final searched level. This -is how the search represents a direct early transition such as: - -```text -L0 A256 -L1 A64 -L2+ uniform D64 -``` - -Non-increasing descent applies between adjacent searched levels: the next A may -be smaller or equal, but never larger. Once the uniform suffix begins, repeated -D64 levels are expected and obey the same monotonic rule. - -### Preprocessing matrix size - -The primary geometry objective inside each exact A-dimension path is the -largest physical base-field footprint of any setup matrix required by the -complete schedule: - -```text -setup_matrix_field_elements_for_schedule(schedule) -``` - -This is the canonical quantity comparable across mixed role dimensions and -different setup-generation dimensions. - -It is not: - -- the sum of all A/B/D matrices at all levels; -- the number of setup-generation ring elements without multiplying by their -physical field width; -- setup-seed serialization size; or -- observed resident memory. - -Akita stores one shared preprocessing vector. Role matrices are prefix views, -so the schedule requires an envelope equal to its largest physical matrix or -setup-prefix footprint. - -## Policy model - -The following is a semantic model, not final Rust syntax: - -```text -enum RingDimensionScheduleMode { - UniformDimension { - ring_dimension: usize, - }, - - AdaptiveDimension { - num_search_levels: usize, - uniform_suffix_dimension: usize, - potential_a_dimensions: &'static [usize], - potential_b_dimensions: &'static [usize], - potential_d_dimensions: &'static [usize], - }, -} -``` - -The setup-generation dimension remains a separate config/policy value. The -mode is carried alongside the existing decomposition policy, SIS identity, -challenge hooks, basis range, chunk policy, recursive-setup policy, setup cap, -and selection policy. - -### UniformDimension - -`UniformDimension` defines one topology: - -```text -L0 through terminal: - d_a = d_b = d_d = ring_dimension -``` - -Examples: - -```text -UniformDimension { ring_dimension: 64 } -UniformDimension { ring_dimension: 128 } -``` - -This mode performs no dimension search. It should preserve existing uniform -schedule descriptors and estimates when all other policy inputs are unchanged. - -### AdaptiveDimension - -`AdaptiveDimension` defines a bounded A search and deterministic B/D derivation. - -An initial fp128 one-hot policy may use: - -```text -AdaptiveDimension { - num_search_levels: 2, - uniform_suffix_dimension: 64, - potential_a_dimensions: [64, 128, 256, 512], - potential_b_dimensions: [64, 128], - potential_d_dimensions: [64, 128], -} -``` - -D512 remains subject to the additional setup-generation and honest-fold -requirements described later. A D256 setup must filter or reject D512 rather -than attempting to search it. - -The lists are role capability domains, not complete A/B/D tuple candidates. -A produces search branches. B and D lists are scanned deterministically after -the A-dependent physical widths are known. - -## Bounded A-dimension brute force - -### Search domain - -At every searched level, the planner considers each supported A dimension that: - -1. is a nonzero power of two; -2. divides the setup-generation dimension; -3. has ring-challenge and fold-arithmetic support; -4. has the required A-role SIS coverage for the derived width and bound; -5. is at least the uniform suffix dimension; and -6. is no larger than the A dimension at the preceding searched level. - -At the root there is no preceding A dimension. The setup-generation dimension -is a capability ceiling, not a required root choice. - -For searched levels `i > 0`: - -```text -d_a[i] <= d_a[i - 1] -``` - -At the boundary to the fixed suffix: - -```text -uniform_suffix_dimension <= d_a[last searched level] -``` - -Equality at the boundary is allowed because the final searched level may have -already transitioned to the suffix dimension. - -### Exact bounded depth - -The planner must not continue A-dimension search after: - -```text -level == num_search_levels - 1 -``` - -At: - -```text -level == num_search_levels -``` - -the only allowed tuple is: - -```text -uniform_suffix_dimension / uniform_suffix_dimension / uniform_suffix_dimension -``` - -This bound is part of catalog identity. Changing it changes the search policy -even if the winning rows happen to remain the same. - -### Search size - -Because A must be non-increasing, the A search is smaller than an unrestricted -per-level product while retaining schedules that keep the same A dimension for -multiple leading folds. - -For four ordered A dimensions and two searched levels, the complete -non-increasing A paths are: - -```text -512 -> 512 -512 -> 256 -512 -> 128 -512 -> 64 -256 -> 256 -256 -> 128 -256 -> 64 -128 -> 128 -128 -> 64 -64 -> 64 -``` - -Protocol support, setup divisibility, contraction, SIS availability, and setup -capacity may remove additional paths. - -The planner does not construct B/D branches for each of these A paths. - -### Block geometry and basis - -Brute-forcing A dimensions does not mean matrix parameters are copied from a -dimension-only table. For every A path, the planner still evaluates the -canonical basis and block-layout choices allowed by the configured planner -policy. - -The dependency remains: - -```text -A dimension - + current input witness - + basis - + block split - + challenge shape - -> A width, bound, and minimum secure rank - -> B/D native widths - -> deterministic B/D dimensions - -> exact outgoing witness - -> complete continuation -``` - -A path is not comparable until the complete schedule has been constructed and -priced. - -## Deterministic B and D dimension selection - -### No B/D search branches - -For one fixed A-level candidate, B and D are derived independently. Their -dimension alternatives do not create multiple child schedules. - -The planner scans each role's candidate list in ascending dimension order. It -tracks the supported dimension producing the smallest exact secure rank and -stops early only when rank one is reached: - -```text -choose_role_dimension(role, native_width, d_a, parent_role_ceiling): - best = None - - for d in potential_role_dimensions ascending: - skip unless d <= d_a - skip unless d divides d_a and setup generation - skip unless d <= parent_role_ceiling, when a parent exists - derive projected physical width at d - derive role-local coefficient bound at d - derive minimum secure SIS rank at d - - if best is None or (rank, d) < (best.rank, best.dimension): - best = d and the derived matrix parameters - - if rank == 1: - break - - return best, or candidate infeasible if no admissible matrix exists -``` - -This scan is a deterministic derivation rule, not planner branching: exactly -one B matrix and one D matrix survive for an A/geometry candidate. A secure -rank greater than one does not make the candidate infeasible. - -### Why selection occurs after A derivation - -B's native width depends on A's output rank. Both B and D physical widths -depend on projection from the selected A ring: - -```text -physical_B_width = native_B_width * (d_a / d_b) -physical_D_width = native_D_width * (d_a / d_d) -``` - -Therefore B/D dimensions cannot be selected from A dimension alone. The -planner must first derive the exact A matrix and level geometry. - -### B and D are independent - -The planner applies the minimum-rank scan independently: - -```text -d_b = supported B dimension minimizing (secure rank, dimension) -d_d = supported D dimension minimizing (secure rank, dimension) -``` - -Rank one is an early-stop condition because no larger dimension can improve the -rank below one. It is not a validity requirement. The policy does not require -`d_b == d_d`. - -### Cross-level role ceilings - -A is required to be non-increasing inside the search window. To preserve the -same monotonic transition contract, B and D must not increase: - -```text -d_b[level] <= d_b[level - 1] -d_d[level] <= d_d[level - 1] -``` - -The preceding selected role dimension is therefore a ceiling during the -deterministic scan. If admissible dimensions exist but all produce rank greater -than one, the scan keeps the smallest rank among them. The A/geometry candidate -is infeasible only when no admissible, SIS-supported role matrix exists. - -At the uniform suffix boundary: - -```text -suffix_dimension <= final d_a -suffix_dimension <= final d_b -suffix_dimension <= final d_d -``` - -If these inequalities do not hold, the candidate cannot transition to the -configured suffix. - -### A rank minimization and non-rank-one fallback - -A dimensions are globally searched, but rank comparison must not select an -inferior block geometry merely to lower rank. For each exact A-dimension path, -the planner first chooses that path's best complete schedule by setup fields, -proof bytes, and descriptor bytes. It then compares the resulting path -representatives by the per-level vector: - -```text -[(n_a[0], d_a[0]), (n_a[1], d_a[1]), ...] -``` - -The vector is compared lexicographically. At each searched level, a larger -dimension is useful only when it strictly lowers the minimum secure A rank. An -equal rank keeps the smaller dimension, and rank one prevents any larger -dimension from winning. If every allowed dimension has rank greater than one, -the smallest rank found remains valid. - -This fallback is necessary for workloads such as `nv=40`, where current D256 -coverage requires A rank two. Recursive and terminal A matrices also commonly -have ranks greater than one. B and D may likewise remain above rank one after -their deterministic scans exhaust the allowed dimensions. - -### Known tradeoff - -Choosing B/D by minimum secure rank, with smaller dimension as the tie-break, -is a policy simplification. It is not a proof that equal-rank dimensions are -globally equivalent in preprocessing size, proof bytes, or verifier work. - -This proposal accepts that limitation to avoid B/D brute force. The exact rule -must be catalog-bound so that generation and runtime replay agree. If later -measurements show that the simplification excludes important schedules, a new -selection policy may admit B/D branching explicitly. - -## Required D256 paths - -With: - -```text -num_search_levels = 2 -uniform_suffix_dimension = 64 -potential_a_dimensions containing 64, 128, and 256 -``` - -the A brute-force search must include: - -```text -A path 1: 256 -> 64 -A path 2: 256 -> 128 -A path 3: 256 -> 256 -``` - -For current fp128 one-hot widths, deterministic minimum-rank B/D selection is -expected to materialize the corresponding role topologies: - -```text -path 1: - L0: 256/128/128 - L1: 64/64/64 - L2+: 64/64/64 - -path 2: - L0: 256/128/128 - L1: 128/64/64 - L2+: 64/64/64 - -path 3: - L0: 256/128/128 - L1: 256/64/64 - L2+: 64/64/64 -``` - -The first is the D256 direct path. The second is the required D256 three-band -path: - -```text -256/128/128 -> 128/64/64 -> 64/64/64 -``` - -The dimensions above are expected outcomes, not hard-coded tuples. B/D must be -re-derived from each candidate's exact widths and minimum-rank scan. A regression -test should pin the topology for workloads where the current SIS table produces -these selections. - -The L1 matrices of the three-band path must be constructed from the exact -witness produced by its D256 root. They must not be copied from an independently -planned D128-root schedule. - -For the current `nv=36` representatives, the three L1 A ranks are: - -```text -D64 -> rank 5 -D128 -> rank 3 -D256 -> rank 2 -``` - -No allowed dimension reaches rank one, so path 3 is selected with rank two. - -## Selection objective - -### Per-path geometry objective - -For every valid complete A path and geometry, compute: - -```text -physical_preprocessing_fields = - setup_matrix_field_elements_for_schedule(schedule) -``` - -For each exact A-dimension path, select the schedule with the smallest value. - -The planner must not compare only `SetupMatrixEnvelope::max_setup_len`, because -that value counts setup-generation ring elements and is not directly comparable -across generation dimensions. - -### A-path selection and deterministic tie-breaking - -The complete selection is: - -```text -representative(path) = min_by( - physical_preprocessing_matrix_field_elements, - exact_modeled_proof_payload_bytes, - canonical_schedule_descriptor_bytes, -) - -winner = min_by( - per_level_(A_rank, A_dimension)_vector, - representative_setup_fields, - representative_proof_bytes, - representative_descriptor_bytes, -) -``` - -Optimizing each dimension path before comparing ranks is important. Otherwise, -the planner could choose an unnecessarily expensive block geometry solely -because that geometry happens to lower A rank. Proof bytes select among -schedules with equal preprocessing capacity inside a path. Descriptor bytes -make an exact cost tie deterministic. A-dimension enumeration order, hash-map -order, and thread scheduling must not affect the result. - -### Consequence for the D256-root paths - -Current measurements in the related mixed-dimension spec show that the D256 -direct and three-band schedules can have the same preprocessing footprint: - -```text -D256 direct: 45,088,768 fp128 field elements -D256 three-band: 45,088,768 fp128 field elements -``` - -Under the revised rank-first A-path policy, the path whose representative has -the smaller L1 A rank wins. At `nv=36`, the retained-D256 L1 has rank two and -therefore wins over the three-band rank-three and direct rank-five paths. Setup -and proof bytes decide only after the per-level rank/dimension vectors tie. - -The measured verifier-time advantage of one topology is not part of this -deterministic objective. Adding verifier work requires a separate versioned -cost model. - -### Setup capacity - -Any candidate exceeding the configured physical setup cap is infeasible. -Capacity is a feasibility constraint; it does not replace comparison among the -remaining schedules. - -## Complete adaptive search algorithm - -For one workload under `AdaptiveDimension`: - -1. Validate the search window, suffix dimension, and role capability lists. -2. Start at L0 with every supported A dimension. -3. For every root A dimension, basis, and feasible block split: - 1. Derive A width, coefficient bound, and minimum secure rank. - 2. Derive B's native width and select B by the deterministic minimum-rank - scan. - 3. Derive D's native width and select D by the deterministic minimum-rank - scan. - 4. Derive the exact outgoing witness and reject non-contraction. -4. At each later searched level: - 1. enumerate only A dimensions no larger than the preceding A; - 2. derive A from the exact incoming witness; - 3. derive B/D using the deterministic minimum-rank rule and parent ceilings; - 4. derive the exact outgoing witness; and - 5. retain the required setup/proof continuation frontier. -5. Stop A enumeration after exactly `num_search_levels` leading levels. -6. Transition to uniform `suffix/suffix/suffix`. -7. Use the canonical uniform suffix planner from the exact boundary witness. -8. Reject candidates that cannot transition, contract, terminate, satisfy SIS - coverage, or fit setup capacity. -9. Materialize each complete schedule and recompute exact setup/proof estimates. -10. Group complete schedules by their exact A-dimension path and select the - best geometry in each group by setup fields, proof bytes, and descriptor - bytes. -11. Compare the path representatives by their lexicographic per-level - `(A rank, A dimension)` vectors. A strict rank reduction wins; an equal rank - keeps the smaller dimension; rank one prevents further dimension growth; - and the smallest available rank remains valid when rank one is unavailable. - -An unsupported SIS cell for one B/D dimension causes the role scan to try the -next allowed dimension. An A/geometry candidate becomes infeasible when the -scan finds no admissible SIS-supported matrix for either role. Malformed config, -inconsistent catalog identity, invalid dimension arithmetic, or an invalid -capability list is a policy error. If all candidates are infeasible, the -workload is unsupported. - -## Frontier and memoization requirements - -### Non-additive setup objective - -Setup and proof costs compose differently: - -```text -combined.setup = max(level.setup, child.setup) -combined.proof = level.proof + child.proof -``` - -The planner cannot retain only one locally best suffix. A larger parent may -mask two child setup footprints, after which the child with fewer proof bytes -wins. - -The planner must retain the nondominated setup/proof alternatives needed by the -complete-schedule objective, partitioned by exact first-child parameters where -parent proof pricing depends on them. - -### Adaptive memo state - -The memo state must distinguish at least: - -```text -level -input witness length -current basis -previous A dimension -previous selected B dimension -previous selected D dimension -remaining searched levels or absolute boundary -``` - -Once the search enters the uniform suffix, dimension state canonicalizes to the -configured suffix dimension and can reuse the ordinary uniform suffix state. - -### B/D derivation and memoization - -B/D choices need not be stored as alternative branches, but their selected -dimensions are parent-visible transition ceilings and part of the exact fold -descriptor. Memo keys or state partitioning must not merge suffixes reached -through incompatible B/D selections. - -## Validation requirements - -### Mode validation - -- `UniformDimension.ring_dimension` is a nonzero supported power of two and, - in the current uniform engine, equals the setup-generation dimension. -- `AdaptiveDimension.num_search_levels` is positive. -- The uniform suffix dimension is a nonzero supported power of two. -- Each potential dimension list is nonempty, sorted, and unique. -- Every potential dimension divides the setup-generation dimension or is -rejected as incompatible with that config. -- The suffix dimension appears in all three role capability domains, and no - listed role dimension is smaller than the suffix. - -### A-domain validation - -- Every A dimension has challenge and fold support. -- Every A dimension is at least the suffix dimension. -- The domain contains at least one A dimension at or above the suffix -dimension. -- Search never increases A inside the configured search window; repeating the -preceding A dimension is allowed. - -### B/D-domain validation - -- Every B/D dimension has role-local SIS and execution support. -- D512 must not be inferred for B or D merely because it appears in the A list. -- B and D domains may differ. -- The deterministic ascending minimum-rank rule and its rank-one early stop are -bound into policy identity. - -### Transition validation - -Inside the search window: - -```text -child.d_a <= parent.d_a -child.d_b <= parent.d_b -child.d_d <= parent.d_d -``` - -At the suffix boundary: - -```text -suffix <= parent.d_a -suffix <= parent.d_b -suffix <= parent.d_d -``` - -After the boundary, every fold and terminal use the uniform suffix dimension. - -## D512 policy - -D512 may appear in `potential_a_dimensions`, but only when the surrounding -policy supports it. - -### Setup generation - -A D512 role requires a setup-generation dimension divisible by 512. A current -D256 mixed setup cannot admit D512. - -### Role support - -Current fp128 support treats D512 as an A-role experiment. It does not certify -uniform D512 B/D matrices. Therefore an initial adaptive policy may use: - -```text -potential_a_dimensions = [64, 128, 256, 512] -potential_b_dimensions = [64, 128] -potential_d_dimensions = [64, 128] -``` - -It must not derive `512/512/512`. - -### Honest-fold sizing - -Current D256 and D512 one-hot presets use different root honest-fold norm -inputs. Combining them in one A search requires either: - -- a dimension-dependent honest-fold sizing hook; or -- one conservative policy proven valid across the complete A domain. - -Until setup generation and honest-fold sizing are resolved, D512 must be -filtered from configs that cannot support it rather than producing a partially -valid search. - -## Current `mixed_search.rs` boundary - -### Why it exists - -`find_schedule` now dispatches directly from the catalog-bound enum: - -```text -UniformDimension -> find_schedule_inner -AdaptiveDimension -> mixed_search::find_schedule -``` - -The uniform suffix DP assumes one dimension throughout its state. The adaptive -orchestration module adds: - -- per-level dimension state; -- component-wise transition ceilings; -- candidate-local A challenges; -- the forced uniform suffix boundary; -- prevention of early terminal selection; -- setup/proof frontier retention; and -- per-path geometry selection followed by rank-first A-path selection. - -The module is search orchestration, not a separate source of matrix security or -protocol geometry. It calls canonical candidate, SIS, proof-size, witness, and -setup primitives. - -### Consolidation under the enum - -The public design uses one topology-aware planner entry point: - -```text -find_schedule(policy) - -> UniformDimension: one fixed uniform path - -> AdaptiveDimension: bounded non-increasing A search with derived B/D -``` - -Root and recursive matrix construction, termination, materialization, and exact -estimate revalidation are shared. The adaptive module owns only the additional -A-path/frontier state and the transition to the existing uniform suffix. - -The preprocessing-first objective applies inside every exact A path. Comparing -A ranks before selecting a path representative would be incorrect because it -could distort block geometry solely to obtain a lower rank. Once every path has -its canonical representative, per-level A rank/dimension comparison selects -among paths. - -Moving the remaining adaptive frontier into the uniform suffix engine is an -optional internal consolidation. `mixed_search.rs` may be removed only when: - -1. one planner handles both enum modes; -2. adaptive memo state carries the required A and derived B/D ceilings; -3. the common frontier implements per-path preprocessing-first semantics; -4. uniform regressions remain unchanged where policy is unchanged; -5. adaptive selections agree with a bounded unpruned reference traversal; and -6. no planner branch refers to `OneHot` by name. - -Simply moving the current module's contents into another file is not -consolidation. - -## Configuration ownership - -### CommitmentConfig surface - -`CommitmentConfig` should project the enum mode and its static dimension domains -into the plain-value planner/runtime policy. - -Configuration remains the single source of truth for: - -```text -setup-generation dimension -ring-dimension schedule mode -number of searched levels -uniform suffix dimension -A/B/D capability domains -A/B/D minimum-rank derivation rules and rank-one early stops -selection objective -decomposition and basis range -SIS identity -challenge and honest-fold policy -chunk policy -recursive-setup policy -generated catalog -``` - -Environment variables must not alter catalog-bound policy during proving or -verification. - -### Avoiding OneHot special-casing - -The planner must dispatch on `RingDimensionScheduleMode`, not on the type name -`OneHot`. - -Whether the marker type remains temporarily as a concrete catalog/setup policy -identity is a separate cleanup decision. The requirement is one canonical -implementation, not necessarily immediate deletion of every named zero-sized -policy type. - -### Adapters - -Recursive-setup and multi-chunk adapters must explicitly preserve, narrow, or -reject `AdaptiveDimension`. They must not inherit an adaptive search domain -accidentally when their planner path supports only uniform D64. - -## Generated schedule table storage - -The offline emitter writes generated Rust modules under: - -```text -crates/akita-schedules/src/generated/ -``` - -The bootstrap command is: - -```bash -scripts/generate-schedule-tables.sh -``` - -For the current native fp128 mixed family, the generated files are: - -```text -fp128_onehot.rs -fp128_onehot_precommitted.rs -``` - -Large generated `fp*.rs` family files are intentionally ignored by Git and -recreated locally and in CI. The checked-in `generated/mod.rs` supplies -feature-gated wiring and constructs the `GeneratedScheduleTable`. - -Generated rows are compact Rust static data. Runtime expansion reconstructs -widths, SIS keys, and secure ranks through canonical primitives. - -The current `fp128_onehot` generated family contains only: - -```text -nv = 32 -num_polynomials = 1 -``` - -The complete adaptive search policy—not only the winning dimension path—must -be bound into catalog identity. Generated runtime rows need contain only the -selected schedule. - -## Current benchmark and config mapping - -The repository currently exercises mixed dimensions through distinct paths. - - -| Experiment | Effective config | Schedule source | -| ------------------------------------ | ------------------------------------------------------------------------------------ | ----------------------------------- | -| Stock `onehot_fp128`, nv32 | `OneHot` | Generated runtime catalog | -| Planner diagnostic, nv18–nv40 | Policy derived from `OneHot` | Direct offline `find_schedule` call | -| D256 direct timing profile | `MixedDConfig` | Synthetic test-support builder | -| Historical D256 three-band profile | D256 root, uniform-D128 middle policy, D64 suffix | Synthetic test-support builder | - - -### Native generated adaptive benchmark - -The stock mode: - -```text -AKITA_MODE=onehot_fp128 -``` - -uses `fp128::OneHot`, fixes nv32, calls -`Cfg::runtime_schedule`, and gives that exact generated row to the PCS prover -and verifier. - -### Direct offline diagnostics - -The `mixed_dimension_search` example derives policy from -`OneHot` but calls the offline planner directly. The nv18, nv24, -nv32, nv36, and diagnostic over-cap nv40 results discussed in this design -review came from this path and are not current runtime catalog rows. - -### Synthetic D256 profiles - -The measured D256 direct and three-band schedules currently use test-support -config adapters. They do not use the native mixed generated table. - -Under this proposal, a two-level bounded A search includes these A paths: - -```text -256 -> 64 -256 -> 128 -256 -> 256 -``` - -After deterministic B/D selection and uniform-D64 suffix planning, the -rank/dimension rule may select any of these paths. For current `nv=36`, the -representatives have L1 A ranks 5, 3, and 2 respectively, so `256 -> 256` -wins. Once generated-catalog coverage and equivalent protocol tests exist, the -synthetic adapters may be removed. - -## Catalog and runtime boundary - -Adaptive search remains offline: - -```text -CommitmentConfig - -> RingDimensionScheduleMode - -> bounded A search and deterministic B/D derivation - -> selected generated row -``` - -Runtime proving and verification perform only: - -```text -validate catalog identity -look up the exact workload key -expand the frozen selected row -reject a missing row -``` - -Runtime must not rerun A search or select B/D based on locally observed ranks. - -Catalog identity must bind: - -- enum mode and stable variant identity; -- setup-generation dimension; -- number of searched levels; -- uniform suffix dimension; -- ordered A/B/D dimension capability domains; -- non-increasing A and B/D monotonic ceiling rules; -- deterministic B/D minimum-rank selection, smaller-dimension tie-break, and -rank-one early-stop semantics; -- deterministic A rank/dimension path selection, non-rank-one fallback, and - rank-one early-stop semantics; -- preprocessing/proof/descriptor representative selection inside each exact A - path; -- SIS modulus profile, security policy, and table digest; -- challenge coverage over the complete A domain; -- honest-fold sizing identity; -- decomposition and basis range; -- chunk policy; and -- recursive-setup policy. - -Changing any of these invalidates the catalog even when current winning rows do -not change. - -## Implementation sequence - -This section describes a possible future sequence; it does not authorize code -changes. - -### Cut 1: policy and identity - -1. Add `UniformDimension` and `AdaptiveDimension`. -2. Add search-level, suffix, and role capability fields. -3. Define and bind the deterministic B/D minimum-rank rule and rank-one early - stop. -4. Define and bind A path representative selection followed by per-level - rank/dimension selection and non-rank-one fallback. -5. Extend catalog identity with every new semantic input. -6. Express existing uniform configs through `UniformDimension`. - -### Cut 2: bounded adaptive engine - -1. Enumerate non-increasing A paths only inside the configured window. -2. Derive B/D without branching. -3. Preserve exact setup/proof frontiers inside each A path. -4. Hand the exact boundary witness to the uniform suffix planner. -5. Select each path representative by preprocessing fields, proof bytes, and - descriptor bytes, then select the A path by per-level rank and dimension. - -### Cut 3: D256 generated coverage - -1. Add workloads that exercise A paths `256 -> 64`, `256 -> 128`, and - `256 -> 256`. -2. Pin derived D256 role topologies where current SIS data supports them. -3. Compare generated/runtime replay with current synthetic protocol coverage. -4. Remove synthetic adapters only after coverage is equivalent. - -### Cut 4: planner consolidation - -1. Generalize the common schedule state over the enum mode. -2. Remove config-name dispatch. -3. Delete `mixed_search.rs` when its state/frontier behavior is fully owned by - the common engine. - -### Cut 5: optional D512 admission - -1. Resolve D512 setup generation. -2. Resolve dimension-dependent honest-fold sizing. -3. Validate D512 A-role search with D128/D64 B/D derivation. -4. Regenerate catalogs under the new identity. - -## Required tests - - -| Area | Required property | -| ------------------------- | --------------------------------------------------------------------------------------------------------------- | -| Enum validation | Uniform and adaptive modes reject malformed policy data | -| Uniform preservation | Equivalent `UniformDimension` policies preserve existing descriptors and estimates | -| Search boundary | A is enumerated only at levels `< num_search_levels` | -| Non-increasing A | Smaller and equal A transitions are accepted; increasing A transitions inside the search window are rejected | -| Suffix boundary | Level `num_search_levels` and later, including terminal, are uniform at the configured suffix dimension | -| A enumeration | Every supported non-increasing A path in the bounded domain is considered | -| Per-path representative | Each exact A path first selects its best complete setup/proof/descriptor geometry | -| A rank scan | Path representatives minimize A rank at each searched level; rank one stops dimension growth | -| A rank tie | Equal A ranks prefer the smaller A dimension | -| A non-rank-one fallback | If no allowed A dimension reaches rank one, the smallest secure rank remains valid | -| No B/D branching | Each A/geometry candidate produces at most one derived B and one derived D choice | -| B rank scan | B dimensions are tried in ascending order, the lowest exact secure rank wins, and rank one stops the scan early | -| D rank scan | D dimensions are tried in ascending order, the lowest exact secure rank wins, and rank one stops the scan early | -| B/D rank tie | Equal secure ranks select the smaller role dimension | -| B/D non-rank-one fallback | If no dimension reaches rank one, the lowest-rank supported B/D matrix remains valid | -| B/D infeasibility | An A/geometry candidate is infeasible only when a role has no admissible SIS-supported dimension | -| Role monotonicity | Derived B/D dimensions do not increase across searched levels | -| A rank | A candidates with rank greater than one remain eligible only when no allowed dimension lowers that rank | -| D256 direct | The two-level search can derive `256/128/128 -> 64/64/64 -> D64` | -| D256 three-band | The two-level search can derive `256/128/128 -> 128/64/64 -> D64` from exact boundary witnesses | -| Objective | A rank/dimension paths win first; setup, proof, and descriptor select the representative within each path | -| Setup tie | Equal preprocessing sizes within one A path compare proof bytes, then descriptor bytes | -| Frontier | Parent-masked child setup differences retain the correct lower-proof alternative | -| Setup cap | Over-capacity candidates do not exclude valid siblings | -| D512 setup | D512 A candidates reject under D256 setup generation | -| D512 roles | D512 is never inferred for unsupported B/D roles | -| Catalog drift | Changing domains, search depth, suffix, B/D rule, or objective invalidates catalogs | -| Runtime boundary | Missing rows reject without planner fallback | -| Adapter policy | Recursive and multi-chunk adapters explicitly preserve, narrow, or reject adaptive mode | - - -## Acceptance criteria - -The first implementation is complete when: - -1. `RingDimensionScheduleMode` exposes `UniformDimension` and - `AdaptiveDimension`. -2. `AdaptiveDimension` carries a bounded leading search depth, uniform suffix, - and separate A/B/D capability domains. -3. Only A dimensions produce search branches. -4. A is smaller than or equal to its preceding dimension between adjacent - searched levels. -5. A search stops at the configured boundary. -6. B and D are independently derived by ascending dimension scans that minimize - exact secure rank, stop early at rank one, and prefer smaller dimensions on - rank ties. -7. A uses the smallest secure rank available at each searched level, prefers - the smaller dimension on a rank tie, and remains valid above rank one when - the domain cannot reduce it further. -8. Each exact A-dimension path first selects its best complete schedule by - preprocessing fields, proof bytes, and descriptor bytes; path - representatives are then selected by their per-level A rank/dimension vector. -9. A two-level search includes both D256 paths: - ```text - 256/128/128 -> 64/64/64 -> D64 - 256/128/128 -> 128/64/64 -> D64 - ``` -10. Planner logic contains no branch keyed on `OneHot`. -11. Runtime remains generated-catalog-only. - -## Remaining implementation questions - -The main policy direction is resolved. These implementation-level questions -remain: - -1. Should invalid dimensions be rejected when constructing the policy, or - filtered as unsupported capabilities before catalog identity is computed? -2. Should `num_search_levels` be capped by a small protocol constant to bound - adversarial custom policies in offline tools? -3. Should basis and block-split enumeration remain exhaustive at every searched - A level or use the current canonical suffix split heuristic at later levels? -4. Which config type initially owns the adaptive policy after planner - special-casing is removed? -5. Which adapters narrow adaptive mode to uniform D64? -6. What honest-fold API is required before D512 enters the active A domain? From 6e0f28ac3598268f9997d7bd18267cb8086c3a64 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Thu, 6 Aug 2026 14:48:15 -0700 Subject: [PATCH 10/24] refactor(config): remove standalone fp128 d64 catalogs --- .github/workflows/ci.yml | 2 +- .github/workflows/profile-bench.yml | 6 +- PR_DESCRIPTION.md | 8 +- book/src/usage/profiling.md | 32 +- book/src/usage/quickstart.md | 10 +- crates/akita-config/Cargo.toml | 6 +- crates/akita-config/src/lib.rs | 26 +- .../src/precommitted_commitment.rs | 6 +- .../akita-config/src/proof_optimized/fp128.rs | 31 +- .../akita-config/src/proof_optimized/tests.rs | 9 +- .../akita-config/src/recursive_commitment.rs | 6 +- crates/akita-config/tests/generated_tables.rs | 43 +- crates/akita-config/tests/runtime_fallback.rs | 139 +----- .../tests/schedule_catalog_feature_off.rs | 8 +- .../tests/schedule_catalog_miswire.rs | 10 +- crates/akita-pcs/Cargo.toml | 6 +- crates/akita-pcs/examples/profile/main.rs | 4 +- crates/akita-pcs/examples/profile/modes.rs | 51 +- crates/akita-pcs/tests/common/mod.rs | 11 +- crates/akita-pcs/tests/single_poly_e2e.rs | 30 +- .../akita-planner/src/generated_families.rs | 23 +- crates/akita-schedules/Cargo.toml | 4 - .../src/generated/fp128_d64_dense.rs | 220 --------- .../generated/fp128_d64_dense_precommitted.rs | 15 - .../src/generated/fp128_d64_onehot.rs | 442 ------------------ .../fp128_d64_onehot_precommitted.rs | 16 - .../src/generated/fp128_onehot.rs | 278 ++++++++++- crates/akita-schedules/src/generated/mod.rs | 28 -- crates/akita-setup/src/lib.rs | 4 +- crates/akita-verifier/Cargo.toml | 2 +- .../src/protocol/core/terminal_ntt.rs | 6 +- .../src/protocol/evaluation_trace.rs | 2 +- crates/akita-verifier/src/stages/stage3.rs | 7 +- scripts/check_profile_ci_features.sh | 3 +- scripts/profile_bench_report.py | 4 +- 35 files changed, 429 insertions(+), 1069 deletions(-) delete mode 100644 crates/akita-schedules/src/generated/fp128_d64_dense.rs delete mode 100644 crates/akita-schedules/src/generated/fp128_d64_dense_precommitted.rs delete mode 100644 crates/akita-schedules/src/generated/fp128_d64_onehot.rs delete mode 100644 crates/akita-schedules/src/generated/fp128_d64_onehot_precommitted.rs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index cc566c54b..b9ad2fcb4 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -201,7 +201,7 @@ jobs: - 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 86f486563..92330a641 100644 --- a/.github/workflows/profile-bench.yml +++ b/.github/workflows/profile-bench.yml @@ -68,13 +68,13 @@ jobs: # (large m_vars), so the public setup matrix grows ~4x per +2 nv: ~1 GiB # at nv=26, ~4 GiB at nv=28, and ~72 GiB at nv=32 (which OOM-aborts the # runner during setup). nv=26 keeps the tensor setup vector (~1 GiB) and - # peak RSS on par with the flat onehot_fp128_d64 nv=32 cell that already + # peak RSS on par with the flat onehot_fp128 nv=32 cell that already # passes here, while still exercising the tensor root fold plus multiple # recursive flat folds. group: - name: 1-fp128-dense cases: | - dense_fp128_d64:24:1 + dense_fp128:24:1 - name: 2-fp128-tensor cases: | onehot_fp128_d64_tensor:26:1 @@ -82,9 +82,7 @@ jobs: cases: | onehot_fp32_d128:28:1 onehot_fp64_d128:28:1 - onehot_fp128_d64:32:1 onehot_fp128:32:1 - onehot_fp128_d64:30:4 - name: 4-multi-group-recursive-direct cases: | onehot_fp128_d64_multi_group_recursive:32:4:direct diff --git a/PR_DESCRIPTION.md b/PR_DESCRIPTION.md index cfa19ba51..4967d5cb2 100644 --- a/PR_DESCRIPTION.md +++ b/PR_DESCRIPTION.md @@ -91,7 +91,7 @@ Terminal: D64 The generated table currently contains direct one-hot rows for `nv = 32` and `nv = 36`. -The explicit uniform `fp128::D64OneHot` preset remains available as a baseline. +The former standalone uniform D64 one-hot catalog has been removed. ### Default fp128 dense configuration @@ -102,8 +102,8 @@ bounds and honest-fold policy. The generated `fp128_dense` catalog covers the existing fp128 dense scalar and batched key set. `fp128_dense_precommitted` stores the corresponding standalone -precommitted descriptors. The explicit uniform `fp128::D64Dense` preset and its -catalog remain available as a baseline and for existing multi-chunk paths. +precommitted descriptors. The former standalone uniform D64 dense catalog has +been removed; existing multi-chunk paths retain their dedicated D64 catalogs. ### Generated catalog identity @@ -180,7 +180,7 @@ Users of the old fp128 D128/D256 one-hot generated families or the `fp128_mixed_ akita_config::proof_optimized::fp128::OneHot ``` -Use `fp128::D64OneHot` when an explicitly uniform D64 direct schedule is required. +Standalone direct fp128 use should select `fp128::OneHot` or `fp128::Dense`. ## Validation diff --git a/book/src/usage/profiling.md b/book/src/usage/profiling.md index 7a18a043a..fe003bdd1 100644 --- a/book/src/usage/profiling.md +++ b/book/src/usage/profiling.md @@ -6,7 +6,7 @@ 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 ``` @@ -14,39 +14,36 @@ AKITA_MODE=onehot_fp128_d64 AKITA_NUM_VARS=32 \ Run from `crates/akita-pcs/`. The harness refuses debug builds unless `AKITA_ALLOW_DEBUG_PROFILE=1`. -This feature-pruned command intentionally measures the explicit uniform-D64 -baseline. With the normal default feature set, omitting `AKITA_MODE` selects -`onehot_fp128` at `nv=32`, the default fp128 one-hot profile. +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 The default direct **fp128** one-hot preset is adaptive: generated tables choose -the first two fold levels and use D64 for the uniform suffix. The explicit -uniform `fp128_d64_onehot` baseline remains available, and recursive presets -remain D64. Shipped tables include `fp128_onehot`, -`fp128_d64_onehot` and `fp128_d64_dense`. +the first two fold levels and use D64 for the uniform suffix. Direct dense uses +the same adaptive policy. Recursive, tensor, 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 one-hot schedules with -`akita_config::proof_optimized::fp128::best_onehot_schedule`. Dense fp128 uses -the single `D64Dense` runtime catalog. +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` normally; `onehot_fp128_d64` in the feature-pruned command | Preset family and representation | -| `AKITA_NUM_VARS` | `32` normally; `25` in the feature-pruned D64 binary | 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 | @@ -61,7 +58,7 @@ 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 ``` @@ -79,10 +76,9 @@ 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` | +| `dense_fp128` | 24 | 1 | `direct` | | `onehot_fp128_d64_tensor` | 26 | 1 | `direct` | -| `onehot_fp128_d64` | 32 | 1 | `direct` | -| `onehot_fp128_d64` | 30 | 4 | `direct` | +| `onehot_fp128` | 32 | 1 | `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` | diff --git a/book/src/usage/quickstart.md b/book/src/usage/quickstart.md index d7401ca96..f031831eb 100644 --- a/book/src/usage/quickstart.md +++ b/book/src/usage/quickstart.md @@ -32,16 +32,14 @@ one-hot preset now chooses dimensions per fold from generated adaptive tables; | Field | Typical production choice | Notes | |-------|---------------------------|--------| -| **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. Explicit uniform `fp128::D64OneHot` remains available, and Jolt/recursive presets remain pinned to D64. Shipped tables include the default and D64 one-hot families plus D64 dense. | +| **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` to compare the -available fp128 one-hot presets for a lookup key. Dense fp128 uses -`fp128::D64Dense` directly. +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 890fc908d..495083219 100644 --- a/crates/akita-config/Cargo.toml +++ b/crates/akita-config/Cargo.toml @@ -20,10 +20,8 @@ readme = "../../README.md" default = ["schedules-default"] test-support = [] schedules-default = [ - "schedules-fp128-d64-onehot", "schedules-fp128-onehot", "schedules-fp128-dense", - "schedules-fp128-d64-dense", "schedules-fp32-d128-onehot", "schedules-fp32-d256-onehot", "schedules-fp64-d128-dense", @@ -40,7 +38,6 @@ all-schedules = [ "schedules-fp128-d64-onehot-multi-chunk-w4r2", "schedules-fp128-d64-dense-multi-chunk", ] -schedules-fp128-d64-onehot = ["akita-schedules/fp128-d64-onehot"] schedules-fp128-onehot = ["akita-schedules/fp128-onehot"] schedules-fp128-dense = ["akita-schedules/fp128-dense"] schedules-fp128-d64-onehot-recursive = [ @@ -49,7 +46,6 @@ schedules-fp128-d64-onehot-recursive = [ schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2 = [ "akita-schedules/fp128-d64-onehot-recursive-multi-chunk-w8r2", ] -schedules-fp128-d64-dense = ["akita-schedules/fp128-d64-dense"] schedules-fp128-d64-onehot-tensor = ["akita-schedules/fp128-d64-onehot-tensor"] schedules-fp128-d64-onehot-multi-chunk = [ "akita-schedules/fp128-d64-onehot-multi-chunk", @@ -87,7 +83,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 fbb625a24..e03a0681d 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -687,10 +687,8 @@ mod fp128_policy_tests { } #[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 current_dense_schedule_stays_within_audited_sis_widths() { + assert_cfg_schedule_stays_within_audited_sis_widths::(CI_SIS_WIDTH_NUM_VARS); } #[test] @@ -699,10 +697,8 @@ mod fp128_policy_tests { } #[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 current_onehot_schedule_stays_within_audited_sis_widths() { + assert_cfg_schedule_stays_within_audited_sis_widths::(CI_SIS_WIDTH_NUM_VARS); } #[test] @@ -711,7 +707,7 @@ mod fp128_policy_tests { type SmallCfg = fp32::D128OneHot; assert_eq!( - ::ring_subfield_embedding_norm_bound(), + ::ring_subfield_embedding_norm_bound(), 1 ); assert_eq!( @@ -734,8 +730,8 @@ mod fp128_policy_tests { fn fp128_generated_singleton_plans_resolve() { let key = PolynomialGroupLayout::singleton(32); - let dense = fp128::D64Dense::runtime_schedule(AkitaScheduleLookupKey::single(key)) - .expect("D64 dense schedule"); + let dense = fp128::Dense::runtime_schedule(AkitaScheduleLookupKey::single(key)) + .expect("adaptive dense schedule"); let onehot = fp128::best_onehot_schedule(key) .expect("selector should resolve onehot schedules") .expect("selector should find a generated onehot schedule"); @@ -770,16 +766,16 @@ 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; + 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_eq!(precommitted.num_live_blocks, 2); assert_ne!(precommitted.inner_commit_matrix.output_rank(), 0); assert_ne!(precommitted.outer_commit_matrix.output_rank(), 0); } @@ -788,7 +784,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 ecfe5a2f2..80b0eeabd 100644 --- a/crates/akita-config/src/precommitted_commitment.rs +++ b/crates/akita-config/src/precommitted_commitment.rs @@ -189,8 +189,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), @@ -201,7 +201,7 @@ 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.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/fp128.rs b/crates/akita-config/src/proof_optimized/fp128.rs index e871713fa..c131c1e49 100644 --- a/crates/akita-config/src/proof_optimized/fp128.rs +++ b/crates/akita-config/src/proof_optimized/fp128.rs @@ -82,12 +82,7 @@ impl_proof_optimized_preset!( 64, 128, 128, - fold_norms = akita_types::sis::FoldWitnessNorms::bounded(3, 64), - schedules = ( - "schedules-fp128-d64-dense", - "fp128_d64_dense", - fp128_d64_dense_table - ) + fold_norms = akita_types::sis::FoldWitnessNorms::bounded(3, 64) ); impl_proof_optimized_preset!( Dense, @@ -115,12 +110,7 @@ impl_proof_optimized_preset!( 64, 128, 1, - fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 1), - schedules = ( - "schedules-fp128-d64-onehot", - "fp128_d64_onehot", - fp128_d64_onehot_table - ) + fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 1) ); impl_proof_optimized_preset!( D64OneHotK16, @@ -202,12 +192,8 @@ impl_multi_chunk_companion!( /// Concrete fp128 preset selected by a schedule-family query. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Fp128Preset { - /// Dense uniform `D=64` preset. - D64Dense, /// Dense preset with adaptive per-level ring dimensions. Dense, - /// Binary onehot generated `D=64` preset. - D64OneHot, /// Binary onehot preset with adaptive per-level ring dimensions. OneHot, } @@ -216,22 +202,19 @@ impl Fp128Preset { /// Setup-generation ring dimension used by this preset. pub const fn ring_dimension(self) -> usize { match self { - Self::D64Dense | Self::D64OneHot => 64, Self::Dense | Self::OneHot => 256, } } /// Whether this preset is onehot-oriented. pub const fn is_onehot(self) -> bool { - matches!(self, Self::D64OneHot | Self::OneHot) + matches!(self, Self::OneHot) } /// Stable human-readable preset name. pub const fn name(self) -> &'static str { match self { - Self::D64Dense => "D64Dense", Self::Dense => "Dense", - Self::D64OneHot => "D64OneHot", Self::OneHot => "OneHot", } } @@ -312,8 +295,8 @@ where pub fn best_onehot_schedule( key: PolynomialGroupLayout, ) -> Result, AkitaError> { - Ok(best_by_exact_bytes([ - candidate::(Fp128Preset::D64OneHot, key)?, - candidate::(Fp128Preset::OneHot, key)?, - ])) + Ok(best_by_exact_bytes([candidate::( + Fp128Preset::OneHot, + key, + )?])) } diff --git a/crates/akita-config/src/proof_optimized/tests.rs b/crates/akita-config/src/proof_optimized/tests.rs index 4a1b07a61..25aeb0998 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"); @@ -136,8 +136,7 @@ fn fp128_adaptive_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() diff --git a/crates/akita-config/src/recursive_commitment.rs b/crates/akita-config/src/recursive_commitment.rs index dab5be1eb..c9e0b03c2 100644 --- a/crates/akita-config/src/recursive_commitment.rs +++ b/crates/akita-config/src/recursive_commitment.rs @@ -112,11 +112,7 @@ impl CommitmentConfig for RecursiveCommitmentConfig } } -#[cfg(all( - test, - feature = "schedules-fp128-d64-onehot", - feature = "schedules-fp128-d64-onehot-recursive" -))] +#[cfg(all(test, feature = "schedules-fp128-d64-onehot-recursive"))] mod tests { use super::*; use crate::proof_optimized::fp128; diff --git a/crates/akita-config/tests/generated_tables.rs b/crates/akita-config/tests/generated_tables.rs index eacb07a56..9c14b0807 100644 --- a/crates/akita-config/tests/generated_tables.rs +++ b/crates/akita-config/tests/generated_tables.rs @@ -43,8 +43,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); @@ -74,7 +73,6 @@ fn family_catalog_is_linked(family: &GeneratedFamily) -> bool { match family.module_name { "fp128_onehot" => fp128::OneHot::schedule_catalog().is_some(), "fp128_dense" => fp128::Dense::schedule_catalog().is_some(), - "fp128_d64_onehot" => fp128::D64OneHot::schedule_catalog().is_some(), "fp128_d64_onehot_recursive" => { as CommitmentConfig>::schedule_catalog() .is_some() @@ -83,7 +81,6 @@ fn family_catalog_is_linked(family: &GeneratedFamily) -> bool { as CommitmentConfig>::schedule_catalog() .is_some() } - "fp128_d64_dense" => fp128::D64Dense::schedule_catalog().is_some(), "fp128_d64_onehot_tensor" => { tensor_verifier::fp128::D64OneHotTensor::schedule_catalog().is_some() } @@ -212,13 +209,13 @@ 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, - fp128::D64Dense::fold_challenge_shape_at_level, + &policy_of::(), + fp128::Dense::ring_challenge_config, + fp128::Dense::fold_challenge_shape_at_level, ) .expect_err("non-v1 protocol epoch must not validate"); assert!(error.to_string().contains("catalog identity mismatch")); @@ -227,14 +224,14 @@ 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, - fp128::D64Dense::fold_challenge_shape_at_level, + fp128::Dense::ring_challenge_config, + fp128::Dense::fold_challenge_shape_at_level, ) .expect_err("planner-policy mismatch must not validate"); assert!( @@ -260,7 +257,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 { @@ -277,19 +274,11 @@ fn equal_lookup_keys_form_one_contiguous_candidate_range() { #[cfg(feature = "all-schedules")] #[test] -fn mixed_catalog_identity_binds_nonwinning_dimensions() { +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"); - assert!(catalog.entries.iter().all(|entry| entry - .root - .final_group - .commitment - .inner_commit_matrix - .ring_dimension - != 128)); - let mut mutated = catalog; let akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { num_search_levels, @@ -346,14 +335,12 @@ fn family_catalog( match family.module_name { "fp128_onehot" => prepare_family_catalog::(family, keys), "fp128_dense" => prepare_family_catalog::(family, keys), - "fp128_d64_onehot" => prepare_family_catalog::(family, keys), "fp128_d64_onehot_recursive" => prepare_family_catalog::< akita_config::RecursiveCommitmentConfig, >(family, keys), "fp128_d64_onehot_recursive_multi_chunk_w8r2" => prepare_family_catalog::< akita_config::RecursiveCommitmentConfig, >(family, keys), - "fp128_d64_dense" => prepare_family_catalog::(family, keys), "fp128_d64_onehot_tensor" => { prepare_family_catalog::(family, keys) } @@ -408,18 +395,12 @@ fn assert_family_group_batch_table_hit(family: &GeneratedFamily, requests: &[Gro "fp128_dense" => { 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, >(family.module_name, requests), "fp128_d64_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_d64_onehot_tensor" => assert_group_batch_table_hits::< tensor_verifier::fp128::D64OneHotTensor, >(family.module_name, requests), @@ -499,14 +480,12 @@ fn resolve_family_group_batch_schedule( match family.module_name { "fp128_onehot" => table_backed_group_batch_schedule::(request), "fp128_dense" => 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, >(request), "fp128_d64_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_tensor" => { 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 f5a5af213..d2e97cf84 100644 --- a/crates/akita-config/tests/runtime_fallback.rs +++ b/crates/akita-config/tests/runtime_fallback.rs @@ -32,31 +32,6 @@ fn table_miss_key(num_vars: usize) -> PolynomialGroupLayout { PolynomialGroupLayout::new(num_vars, 3) } -fn assert_schedule_eq( - label: &str, - lhs: &akita_types::FoldSchedule, - rhs: &akita_types::FoldSchedule, -) { - assert_eq!( - format!("{:?}", lhs.root), - format!("{:?}", rhs.root), - "{label}: root diverges" - ); - assert_eq!( - format!("{:?}", lhs.recursive_folds), - format!("{:?}", rhs.recursive_folds), - "{label}: recursive folds diverge" - ); - assert_eq!( - lhs.terminal.input_witness_len, rhs.terminal.input_witness_len, - "{label}: terminal witness lengths diverge" - ); - assert_eq!( - lhs.terminal.params.response_shape, rhs.terminal.params.response_shape, - "{label}: terminal witness shapes diverge" - ); -} - fn check_table_miss_rejection(num_vars: usize) { let key = table_miss_key(num_vars); @@ -84,14 +59,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"); @@ -136,7 +111,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"); @@ -188,7 +163,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"); @@ -249,7 +224,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"); @@ -295,13 +270,12 @@ fn resolved_row_audit_rejects_each_noncanonical_terminal_shape_field() { } #[test] -fn recursive_adapter_delegates_scalar_keys_to_the_ordinary_catalog() { +fn removed_d64_scalar_catalog_rejects_through_recursive_adapter() { 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); + assert!(matches!( + RecursiveCommitmentConfig::::runtime_schedule(key), + Err(akita_field::AkitaError::UnsupportedSchedule(_)) + )); } #[test] @@ -387,15 +361,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::(); } #[test] -fn offline_planner_admits_dense_multi_group_roots() { - type Cfg = fp128::D64Dense; +fn adaptive_dense_rejects_multi_group_roots() { + type Cfg = fp128::Dense; const PRE_NV: usize = 16; const FINAL_NV: usize = 20; @@ -411,7 +384,7 @@ fn offline_planner_admits_dense_multi_group_roots() { precommitteds: vec![CommittedGroupProfile::from_params(pre_group, &pre_params)], }; let precommitted_honest_fold_policies = vec![Cfg::root_honest_fold_policy()]; - let planned = find_schedule( + let error = find_schedule( &key, Cfg::root_honest_fold_policy(), &precommitted_honest_fold_policies, @@ -419,21 +392,16 @@ fn offline_planner_admits_dense_multi_group_roots() { Cfg::ring_challenge_config, Cfg::fold_challenge_shape_at_level, ) - .expect("dense multi-group schedule"); - - assert_eq!( - planned.schedule.root.params.precommitted_groups.len(), - key.precommitteds.len() - ); - planned - .schedule - .validate_structure() - .expect("dense grouped schedule structure"); + .expect_err("adaptive dense multi-group planning is deferred"); + assert!(matches!( + error, + akita_field::AkitaError::UnsupportedSchedule(_) + )); } #[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)); @@ -458,69 +426,6 @@ 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 { - let params = akita_config::committed_group_params::(&group) - .expect("heterogeneous group must resolve"); - CommittedGroupProfile::from_params(group, ¶ms) -} - -#[test] -fn heterogeneous_group_profiles_match_generated_lookup_and_reject_unlisted_order() { - type Cfg = fp128::D64OneHot; - let onehot_16 = committed_descriptor::(PolynomialGroupLayout::new(14, 1)); - let dense = committed_descriptor::(PolynomialGroupLayout::new(15, 2)); - let key = AkitaScheduleLookupKey { - final_group: PolynomialGroupLayout::new(16, 1), - precommitteds: vec![onehot_16, dense], - }; - - let precommitted_honest_fold_policies = vec![ - akita_types::sis::HonestFoldPolicySpec::UnitOneHot( - akita_types::sis::UnitOneHotFoldPolicy::preserving_existing_behavior( - Cfg::decomposition().field_bits(), - akita_types::sis::FoldWitnessNorms::new(1, 4), - ), - ), - akita_types::sis::HonestFoldPolicySpec::BalancedSignedDigit( - akita_types::sis::BalancedSignedDigitFoldPolicy::preserving_existing_behavior( - Cfg::decomposition().field_bits(), - akita_types::sis::FoldWitnessNorms::bounded(3, Cfg::D), - ), - ), - ]; - let planned = find_schedule( - &key, - Cfg::root_honest_fold_policy(), - &precommitted_honest_fold_policies, - &policy_of::(), - Cfg::ring_challenge_config, - Cfg::fold_challenge_shape_at_level, - ) - .expect("heterogeneous group batch must plan offline"); - - let runtime = Cfg::runtime_schedule(key.clone()).expect("curated mixed catalog row"); - assert_schedule_eq("curated mixed row replay", &runtime, &planned.schedule); - - let reordered = AkitaScheduleLookupKey { - precommitteds: vec![dense, onehot_16], - ..key - }; - assert_ne!( - key.canonical_descriptor_bytes(), - reordered.canonical_descriptor_bytes(), - "ordered per-group contracts must be part of catalog identity" - ); - assert!( - matches!( - Cfg::runtime_schedule(reordered), - Err(akita_field::AkitaError::UnsupportedSchedule(_)) - ), - "an unlisted mixed ordering must reject without runtime planner search" - ); -} 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 8d66ac7a4..eba7b217b 100644 --- a/crates/akita-config/tests/schedule_catalog_miswire.rs +++ b/crates/akita-config/tests/schedule_catalog_miswire.rs @@ -9,17 +9,17 @@ 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, - fp128::D64Dense::fold_challenge_shape_at_level, + &policy_of::(), + fp128::Dense::ring_challenge_config, + fp128::Dense::fold_challenge_shape_at_level, 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 b708590af..808678969 100644 --- a/crates/akita-pcs/Cargo.toml +++ b/crates/akita-pcs/Cargo.toml @@ -49,11 +49,11 @@ profile-ci = [ "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-onehot", "akita-config/schedules-fp128-d64-onehot-recursive", "akita-config/schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2", "akita-config/schedules-fp128-d64-onehot-tensor", - "akita-config/schedules-fp128-d64-dense", + "akita-config/schedules-fp128-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", @@ -61,7 +61,7 @@ profile-ci = [ # Compile the profile example with only the singleton fp128 D64 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"] +profile-onehot-fp128-d64 = ["akita-config/schedules-fp128-onehot"] schedules-fp128-d64-dense-multi-chunk = [ "akita-config/schedules-fp128-d64-dense-multi-chunk", ] diff --git a/crates/akita-pcs/examples/profile/main.rs b/crates/akita-pcs/examples/profile/main.rs index 67e3f9d69..ca4d11050 100644 --- a/crates/akita-pcs/examples/profile/main.rs +++ b/crates/akita-pcs/examples/profile/main.rs @@ -41,7 +41,7 @@ fn main() { } let default_nv = if cfg!(feature = "profile-onehot-fp128-d64") { - 25 + 32 } else { 32 }; @@ -52,7 +52,7 @@ fn main() { let num_polys = env_usize("AKITA_NUM_POLYS", 1); let default_mode = if cfg!(feature = "profile-onehot-fp128-d64") { - "onehot_fp128_d64" + "onehot_fp128" } else { "onehot_fp128" }; diff --git a/crates/akita-pcs/examples/profile/modes.rs b/crates/akita-pcs/examples/profile/modes.rs index 6e822afc9..57cccd311 100644 --- a/crates/akita-pcs/examples/profile/modes.rs +++ b/crates/akita-pcs/examples/profile/modes.rs @@ -177,12 +177,8 @@ struct ProfileMode { #[cfg(all(not(feature = "profile-onehot-fp128-d64"), feature = "profile-ci"))] const PROFILE_CI_MODES: &[ProfileMode] = &[ ProfileMode { - name: "dense_fp128_d64", - run: run_profile_dense_fp128_d64, - }, - ProfileMode { - name: "onehot_fp128_d64", - run: run_profile_onehot_fp128_d64, + name: "dense_fp128", + run: run_profile_dense_fp128, }, ProfileMode { name: "onehot_fp128", @@ -225,12 +221,8 @@ const PROFILE_CI_MODES: &[ProfileMode] = &[ #[cfg(all(not(feature = "profile-onehot-fp128-d64"), not(feature = "profile-ci")))] const PROFILE_ALL_MODES: &[ProfileMode] = &[ ProfileMode { - name: "dense_fp128_d64", - run: run_profile_dense_fp128_d64, - }, - ProfileMode { - name: "onehot_fp128_d64", - run: run_profile_onehot_fp128_d64, + name: "dense_fp128", + run: run_profile_dense_fp128, }, ProfileMode { name: "onehot_fp128", @@ -326,18 +318,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)" @@ -366,24 +346,17 @@ 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(not(feature = "profile-onehot-fp128-d64"))] fn run_profile_onehot_fp128(nv: usize, num_polys: usize) { type Cfg = fp128::OneHot; assert!( @@ -621,14 +594,14 @@ fn resolve_layout>(nv: usize) -> Committed #[cfg(feature = "profile-onehot-fp128-d64")] 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-d64 only supports AKITA_MODE=onehot_fp128", ); assert_eq!( num_polys, 1, "profile-onehot-fp128-d64 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/tests/common/mod.rs b/crates/akita-pcs/tests/common/mod.rs index 429f9257a..0b753e3c8 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(); @@ -342,13 +342,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 { diff --git a/crates/akita-pcs/tests/single_poly_e2e.rs b/crates/akita-pcs/tests/single_poly_e2e.rs index 7bcd9a31e..077aad53d 100644 --- a/crates/akita-pcs/tests/single_poly_e2e.rs +++ b/crates/akita-pcs/tests/single_poly_e2e.rs @@ -5,8 +5,8 @@ //! //! Two polynomial representations are covered: //! -//! * **One-hot** — `fp128::D64OneHot` (D = 64, K = 256). -//! * **Dense** — `fp128::D64Dense` (D = 64, arbitrary field coefficients). +//! * **One-hot** — adaptive `fp128::OneHot` (K = 256). +//! * **Dense** — adaptive `fp128::Dense` (arbitrary field coefficients). //! //! Variable counts: //! @@ -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(); @@ -114,7 +120,7 @@ fn run_single_onehot(nv: usize) { // Dense helpers (D = 64) // --------------------------------------------------------------------------- -type DenseCfg = fp128::D64Dense; +type DenseCfg = fp128::Dense; const DENSE_D: usize = DenseCfg::D; fn run_single_dense(nv: usize) { @@ -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-planner/src/generated_families.rs b/crates/akita-planner/src/generated_families.rs index 6a6734689..c373f13e2 100644 --- a/crates/akita-planner/src/generated_families.rs +++ b/crates/akita-planner/src/generated_families.rs @@ -72,7 +72,7 @@ const FP128_D64_DENSE_KEYS: &[PolynomialGroupLayout] = &[ const FP128_DENSE_KEYS: &[PolynomialGroupLayout] = FP128_D64_DENSE_KEYS; -const FP128_D64_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ +const FP128_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(10), PolynomialGroupLayout::singleton(12), PolynomialGroupLayout::singleton(14), @@ -89,16 +89,12 @@ const FP128_D64_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::new(30, 4), PolynomialGroupLayout::singleton(32), PolynomialGroupLayout::new(32, 4), + PolynomialGroupLayout::singleton(36), PolynomialGroupLayout::singleton(40), PolynomialGroupLayout::singleton(44), PolynomialGroupLayout::singleton(50), ]; -const FP128_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ - PolynomialGroupLayout::singleton(32), - PolynomialGroupLayout::singleton(36), -]; - const FP128_D64_ONEHOT_TENSOR_KEYS: &[PolynomialGroupLayout] = &[PolynomialGroupLayout::singleton(26)]; @@ -726,14 +722,6 @@ 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!( - group_batch, - "fp128_d64_onehot", - "FP128_D64_ONEHOT_SCHEDULES", - "fp128-d64-onehot", - FP128_D64_ONEHOT_KEYS, - fp128::D64OneHot - ), GeneratedFamily { module_name: "fp128_onehot", const_name: "FP128_ONEHOT_SCHEDULES", @@ -772,13 +760,6 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ RecursiveCommitmentConfig, fp128::D64OneHotMultiChunk ), - family_row!( - "fp128_d64_dense", - "FP128_D64_DENSE_SCHEDULES", - "fp128-d64-dense", - FP128_D64_DENSE_KEYS, - fp128::D64Dense - ), GeneratedFamily { module_name: "fp128_dense", const_name: "FP128_DENSE_SCHEDULES", diff --git a/crates/akita-schedules/Cargo.toml b/crates/akita-schedules/Cargo.toml index 7b4b09d08..eb6e8f7d1 100644 --- a/crates/akita-schedules/Cargo.toml +++ b/crates/akita-schedules/Cargo.toml @@ -28,22 +28,18 @@ all-schedules = [ "fp128-d64-dense-multi-chunk", ] schedules-default = [ - "fp128-d64-onehot", "fp128-onehot", "fp128-dense", - "fp128-d64-dense", "fp32-d128-onehot", "fp32-d256-onehot", "fp64-d128-dense", "fp64-d128-onehot", "fp64-d256-onehot", ] -fp128-d64-onehot = [] fp128-onehot = [] fp128-dense = [] fp128-d64-onehot-recursive = [] fp128-d64-onehot-recursive-multi-chunk-w8r2 = [] -fp128-d64-dense = [] fp128-d64-onehot-tensor = [] fp128-d64-onehot-multi-chunk = [] fp128-d64-onehot-multi-chunk-w2r2 = [] diff --git a/crates/akita-schedules/src/generated/fp128_d64_dense.rs b/crates/akita-schedules/src/generated/fp128_d64_dense.rs deleted file mode 100644 index 320d86cee..000000000 --- a/crates/akita-schedules/src/generated/fp128_d64_dense.rs +++ /dev/null @@ -1,220 +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, GeneratedRootFinalChallenge, - GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, - GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, - GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, -}; - -#[rustfmt::skip] -pub(crate) static FP128_D64_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(14, 1), num_digits_inner: 43, num_digits_fold: 4, challenge: GeneratedRootFinalChallenge::Flat, - 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: &[], - 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::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, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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 }, - ], - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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: 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(17, 4), num_digits_inner: 43, num_digits_fold: 4, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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::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(24, 1), num_digits_inner: 43, num_digits_fold: 4, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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 }, - ], - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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 }, - ], - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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::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(32, 1), num_digits_inner: 43, num_digits_fold: 5, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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: 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::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: 43, num_digits_fold: 6, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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: 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::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(50, 1), num_digits_inner: 43, num_digits_fold: 6, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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: 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: 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 }, - }, -]; - -#[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64]; -#[rustfmt::skip] -pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_dense", - protocol_epoch: 3, - 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: 64, - setup_prefix_inner_ring_dimension: 64, - 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, - root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, - ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, - key_count: 10, - key_digest: 7611278421477819350, -}; diff --git a/crates/akita-schedules/src/generated/fp128_d64_dense_precommitted.rs b/crates/akita-schedules/src/generated/fp128_d64_dense_precommitted.rs deleted file mode 100644 index 095db3f11..000000000 --- a/crates/akita-schedules/src/generated/fp128_d64_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_D64_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 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), 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 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), 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 } }, 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(16, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 64, 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_d64_onehot.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot.rs deleted file mode 100644 index 35aae1c3f..000000000 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot.rs +++ /dev/null @@ -1,442 +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, GeneratedRootFinalChallenge, - GeneratedRootFinalGroup, GeneratedRootFold, GeneratedRootPrecommittedGroup, - GeneratedScheduleCatalogIdentity, GeneratedSetupPrefixInput, GeneratedTerminalFold, - GeneratedWitnessPartition, InnerCommitMatrixParams, OuterCommitMatrixParams, - PlannerCostModelId, PolynomialGroupLayout, RingDimensionScheduleMode, SelectionPolicyId, - SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, TensorChallengeShape, -}; - -#[rustfmt::skip] -pub(crate) static FP128_D64_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(12, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 64, positions_per_block: 4, 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: &[], - 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 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(14, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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 }, - ], - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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 }, - ], - 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, 4), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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: 2499, 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 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(15, 2), num_live_ring_elements_per_claim: 512, num_positions_per_block: 32, num_live_blocks: 16, log_basis_inner: 3, num_digits_inner: 43, 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, 5, 1376, 1048575, 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, 6880, 7, 64) }, 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: 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::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 21407, 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 }, - ], - 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: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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: 2499, 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 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(18, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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::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 }, - }, - GeneratedFoldScheduleEntry { - root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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::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(20, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 2), 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, 3, 128, 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: 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::Single, - }, - recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 6746, 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(20, 2), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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::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(20, 2), num_digits_inner: 1, num_digits_fold: 3, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, - ], - 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: 11597, 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::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(20, 4), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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::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(20, 4), num_digits_inner: 1, num_digits_fold: 3, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, - 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, - ], - 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: 15660, 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(20, 4), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, - 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, - 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, - ], - 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: 14528, 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 }, - ], - 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: 1, num_digits_fold: 3, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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::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, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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: 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, 4), num_digits_inner: 1, num_digits_fold: 3, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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::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, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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::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, 2), num_digits_inner: 1, num_digits_fold: 4, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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 } } }, - ], - 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: 794407, positions_per_block: 8192, live_blocks: 97 }, 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: 58491, positions_per_block: 2048, live_blocks: 29 }, 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: 16371, 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(32, 4), num_digits_inner: 1, num_digits_fold: 4, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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 }, - ], - 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, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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: 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: 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(44, 1), num_digits_inner: 1, num_digits_fold: 4, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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: 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::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(50, 1), num_digits_inner: 1, num_digits_fold: 5, challenge: GeneratedRootFinalChallenge::Flat, - 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 } } }, - 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: 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: 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 }, - ], - 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_DIMENSIONS: &[usize] = &[64]; -#[rustfmt::skip] -pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_onehot", - protocol_epoch: 3, - 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: 64, - setup_prefix_inner_ring_dimension: 64, - 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, - root_fold_shape: TensorChallengeShape::Flat, - ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, - ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, - key_count: 24, - key_digest: 9739485853845478637, -}; diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_precommitted.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_precommitted.rs deleted file mode 100644 index e9362bc6c..000000000 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_precommitted.rs +++ /dev/null @@ -1,16 +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_D64_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 }, - 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/fp128_onehot.rs b/crates/akita-schedules/src/generated/fp128_onehot.rs index 8e6f572b6..0de64a292 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot.rs @@ -14,6 +14,205 @@ use super::{ #[rustfmt::skip] 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, challenge: GeneratedRootFinalChallenge::Flat, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 64, positions_per_block: 4, 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: &[], + 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: 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, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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: 1698, positions_per_block: 256, live_blocks: 7 }, 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::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 }, + }, + GeneratedFoldScheduleEntry { + root: GeneratedRootFold { + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(15, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 16, 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: 916, positions_per_block: 128, 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: 2989, 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 }, + ], + terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1992, 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, 4), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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: 1012, positions_per_block: 128, 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: 2989, 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 }, + ], + terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1992, 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(16, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, + 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: 948, positions_per_block: 128, 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: 2989, 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 }, + ], + terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1992, 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(16, 2), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 64, 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: 1012, positions_per_block: 128, 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: 2989, 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 }, + ], + terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1992, 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(18, 1), num_digits_inner: 1, num_digits_fold: 1, challenge: GeneratedRootFinalChallenge::Flat, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2048, positions_per_block: 1024, 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 } } }, + 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: 1502, positions_per_block: 256, live_blocks: 6 }, 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::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::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 }, + }, + GeneratedFoldScheduleEntry { + root: GeneratedRootFold { + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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 }, + }, + GeneratedFoldScheduleEntry { + root: GeneratedRootFold { + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 2), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, + 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: 2596, positions_per_block: 256, live_blocks: 11 }, 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: 3, 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::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7639, 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(20, 4), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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 }, + }, + GeneratedFoldScheduleEntry { + root: GeneratedRootFold { + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(28, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, + 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: 27588, positions_per_block: 512, live_blocks: 54 }, 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::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 20632, 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 }, + ], + 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, challenge: GeneratedRootFinalChallenge::Flat, + 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, challenge: GeneratedRootFinalChallenge::Flat, + 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: 142532, positions_per_block: 512, live_blocks: 279 }, 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: 104951, 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(32, 1), num_digits_inner: 1, num_digits_fold: 3, challenge: GeneratedRootFinalChallenge::Flat, @@ -32,6 +231,24 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ ], 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, 4), num_digits_inner: 1, num_digits_fold: 3, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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(36, 1), num_digits_inner: 1, num_digits_fold: 3, challenge: GeneratedRootFinalChallenge::Flat, @@ -50,6 +267,63 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ ], 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, challenge: GeneratedRootFinalChallenge::Flat, + 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: 2629957, positions_per_block: 4096, live_blocks: 643 }, 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: 398279, positions_per_block: 4096, live_blocks: 98 }, 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: 42365, 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 }, + }, + GeneratedFoldScheduleEntry { + root: GeneratedRootFold { + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(44, 1), num_digits_inner: 1, num_digits_fold: 4, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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: 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 }, + ], + 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(50, 1), num_digits_inner: 1, num_digits_fold: 4, challenge: GeneratedRootFinalChallenge::Flat, + 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: 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: 100925765, positions_per_block: 65536, live_blocks: 1541 }, 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: 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: 2107002, positions_per_block: 16384, live_blocks: 129 }, 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: 99515, positions_per_block: 2048, live_blocks: 49 }, 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: 21531, 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 }, + }, ]; #[rustfmt::skip] @@ -84,6 +358,6 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated 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: 3458533356553718245, - key_count: 2, - key_digest: 11627159412346705112, + key_count: 19, + key_digest: 4526130598428523590, }; diff --git a/crates/akita-schedules/src/generated/mod.rs b/crates/akita-schedules/src/generated/mod.rs index 28c29d124..9fb2bb5b0 100644 --- a/crates/akita-schedules/src/generated/mod.rs +++ b/crates/akita-schedules/src/generated/mod.rs @@ -457,16 +457,10 @@ pub(crate) fn validate_certified_bases( } // @generated schedule module wiring begin -#[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")] @@ -479,8 +473,6 @@ pub mod fp128_d64_onehot_multi_chunk_w2r2_precommitted; 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")] @@ -522,16 +514,6 @@ pub mod fp64_d256_onehot; #[cfg(feature = "fp64-d256-onehot")] pub mod fp64_d256_onehot_precommitted; -#[cfg(feature = "fp128-d64-dense")] -pub fn fp128_d64_dense_table() -> GeneratedScheduleTable { - GeneratedScheduleTable { - entries: fp128_d64_dense::FP128_D64_DENSE_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 { @@ -541,16 +523,6 @@ pub fn fp128_d64_dense_multi_chunk_table() -> GeneratedScheduleTable { } } -#[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 { diff --git a/crates/akita-setup/src/lib.rs b/crates/akita-setup/src/lib.rs index c4a5de7fc..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] @@ -619,7 +619,7 @@ mod tests { fn setup_accepts_field_coupled_presets() { // The D64 catalog begins at nv=14, the first singleton shape with the // required root and suffix folds. - new_prover_setup::(14, 1) + new_prover_setup::(14, 1) .expect("fp128 dense preset should accept the default field"); } diff --git a/crates/akita-verifier/Cargo.toml b/crates/akita-verifier/Cargo.toml index c58262fcf..6a5e46910 100644 --- a/crates/akita-verifier/Cargo.toml +++ b/crates/akita-verifier/Cargo.toml @@ -42,7 +42,7 @@ workspace = true [dev-dependencies] akita-config = { version = "0.1.0", path = "../akita-config", default-features = false, features = [ "test-support", - "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 51177b6db..e3a6f380a 100644 --- a/crates/akita-verifier/src/protocol/core/terminal_ntt.rs +++ b/crates/akita-verifier/src/protocol/core/terminal_ntt.rs @@ -100,7 +100,7 @@ where mod tests { use super::*; 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::{ max_safe_crt_accumulation_width, select_crt_ntt_params, AkitaExpandedSetup, @@ -243,8 +243,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 d7fd19c2f..1aaf7c745 100644 --- a/crates/akita-verifier/src/protocol/evaluation_trace.rs +++ b/crates/akita-verifier/src/protocol/evaluation_trace.rs @@ -335,7 +335,7 @@ mod tests { #[test] fn compact_trace_matches_dense_definition_across_coefficient_blocks() { - type Cfg = fp128::D64Dense; + type Cfg = fp128::Dense; type F = fp128::Field; type E = F; const D: usize = Cfg::D; diff --git a/crates/akita-verifier/src/stages/stage3.rs b/crates/akita-verifier/src/stages/stage3.rs index f8cb77104..4e287ba3a 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,9 +345,8 @@ mod tests { #[test] fn offloaded_setup_ignores_shared_matrix_divisibility() { - let level_params = - committed_group_params::(&PolynomialGroupLayout::singleton(16)) - .expect("level parameters"); + let level_params = committed_group_params::(&PolynomialGroupLayout::singleton(16)) + .expect("level parameters"); let natural_field_len = RING_D + 1; let (setup, offloaded_params) = verifier_setup_with_unaligned_matrix(level_params.clone(), natural_field_len); diff --git a/scripts/check_profile_ci_features.sh b/scripts/check_profile_ci_features.sh index a7ca1e111..5983c5910 100755 --- a/scripts/check_profile_ci_features.sh +++ b/scripts/check_profile_ci_features.sh @@ -19,8 +19,7 @@ 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", + "dense_fp128": "schedules-fp128-dense", "onehot_fp128": "schedules-fp128-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", diff --git a/scripts/profile_bench_report.py b/scripts/profile_bench_report.py index 0b585ce18..0d7d8ccc6 100644 --- a/scripts/profile_bench_report.py +++ b/scripts/profile_bench_report.py @@ -88,11 +88,11 @@ 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 default and D64 one-hot presets, plus D64 tensor and dense. - "onehot_fp128_d64": CaseMetadata("fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64"), + # Direct fp128 one-hot and dense use adaptive generated schedules. "onehot_fp128": CaseMetadata( "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "mixed D256 to D64" ), + "dense_fp128": CaseMetadata("fp128", "dense", "dense", "mixed D256 to D64"), "onehot_fp128_d64_multi_group_recursive": CaseMetadata( "fp128", "onehot", "multi-group one-hot", "D64 recursive multi-group" ), From cdd6a0ac7a12f75d83b895d0311d6c2f1443a7a5 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Thu, 6 Aug 2026 15:20:16 -0700 Subject: [PATCH 11/24] docs: remove PR description draft --- PR_DESCRIPTION.md | 204 ---------------------------------------------- 1 file changed, 204 deletions(-) delete mode 100644 PR_DESCRIPTION.md diff --git a/PR_DESCRIPTION.md b/PR_DESCRIPTION.md deleted file mode 100644 index 4967d5cb2..000000000 --- a/PR_DESCRIPTION.md +++ /dev/null @@ -1,204 +0,0 @@ -# Adaptive ring dimensions for fp128 one-hot - -## Summary - -This PR makes adaptive ring dimensions the default configuration for direct fp128 one-hot and dense commitments. - -Instead of selecting a fixed ring dimension for the entire protocol, the offline planner searches the leading fold levels and selects ring dimensions independently for commitment matrices A, B, and D. Later folds use a uniform D64 suffix. - -The selected schedules are generated ahead of time and stored in the schedule catalog. Proving and verification only load and validate the generated row; they do not run the planner. - -## What changed - -### Declarative ring-dimension policy - -`CommitmentConfig` now describes its ring-dimension behavior using: - -```rust -RingDimensionScheduleMode -``` - -with two variants: - -```rust -UniformDimension { - ring_dimension, -} - -AdaptiveDimension { - num_search_levels, - uniform_suffix_dimension, - potential_a_dimensions, - potential_b_dimensions, - potential_d_dimensions, -} -``` - -Uniform configurations retain the existing single-dimension planner path. - -Adaptive configurations use a bounded offline search over the configured dimensions and fold levels. - -### Adaptive planner - -For the fp128 one-hot configuration, the planner: - -- Searches ring dimensions at L0 and L1. -- Uses D64 uniformly from L2 through the terminal fold. -- Searches A dimensions from `[64, 128, 256]`. -- Derives B and D from `[64, 128]`. -- Requires A dimensions to be non-increasing across searched levels. -- Allows adjacent A dimensions to be equal. -- Computes the exact secure rank for each matrix candidate. - -A is the branching search dimension. B and D do not introduce additional planner branches. For each selected A geometry, the planner scans their allowed dimensions and selects the dimension with the smallest secure rank: - -- Stop increasing the dimension once rank 1 is reached. -- If rank 1 is unavailable, retain the dimension producing the smallest rank. -- Prefer the smaller dimension when two dimensions produce the same rank. - -Complete schedules are selected using the following ordering: - -1. A rank and A dimension at each searched level. -2. Physical preprocessing-matrix footprint. -3. Estimated proof size. -4. Canonical schedule descriptor bytes as the deterministic tie-break. - -This allows larger dimensions when they materially reduce rank without requiring rank 1 in every case. - -### Default fp128 one-hot configuration - -`fp128::OneHot` is now the canonical direct fp128 one-hot preset. - -It uses: - -```text -Setup-generation dimension: D256 -Adaptive levels: L0 and L1 -A candidates: D64, D128, D256 -B candidates: D64, D128 -D candidates: D64, D128 -Uniform suffix: D64 -``` - -For the generated `nv = 36` row, the resulting dimensions are: - -```text -L0: A/B/D = 256/128/128 -L1: A/B/D = 256/64/64 -L2+: A/B/D = 64/64/64 -Terminal: D64 -``` - -The generated table currently contains direct one-hot rows for `nv = 32` and `nv = 36`. - -The former standalone uniform D64 one-hot catalog has been removed. - -### Default fp128 dense configuration - -`fp128::Dense` is the canonical adaptive dense preset. It uses the same D256 -setup-generation envelope, two searched leading levels, candidate dimensions, -and uniform D64 suffix as `fp128::OneHot`, while retaining the dense coefficient -bounds and honest-fold policy. - -The generated `fp128_dense` catalog covers the existing fp128 dense scalar and -batched key set. `fp128_dense_precommitted` stores the corresponding standalone -precommitted descriptors. The former standalone uniform D64 dense catalog has -been removed; existing multi-chunk paths retain their dedicated D64 catalogs. - -### Generated catalog identity - -Generated schedule identity now includes the complete `RingDimensionScheduleMode`, including: - -- Number of adaptive levels. -- Uniform suffix dimension. -- Ordered A candidate dimensions. -- Ordered B candidate dimensions. -- Ordered D candidate dimensions. - -Catalog validation checks that: - -- Every generated fold uses dimensions admitted by the policy. -- A dimensions are non-increasing across adaptive levels. -- The uniform suffix begins at the configured level. -- The terminal uses the configured suffix dimension. -- Every potential A dimension is covered by the challenge-configuration identity. -- Policy changes invalidate stale generated tables. - -Runtime proving and verification remain catalog-only. A missing row is rejected rather than falling back to planner execution. - -### Configuration and catalog cleanup - -Because adaptive one-hot is now the default fp128 configuration, this PR removes redundant fp128 catalogs and presets: - -- D128 one-hot -- D128 one-hot precommitted -- D256 one-hot generated catalog -- D256 one-hot precommitted catalog -- D128 dense -- D128 dense precommitted - -The tableless `D256OneHot` marker remains available for experiments that need a fixed D256 configuration, but it no longer has a shipped runtime catalog. - -The previous `fp128_mixed_dim_onehot` naming has also been removed. The canonical generated family is now simply: - -```text -fp128_onehot -``` - -and the corresponding profiling mode remains: - -```text -onehot_fp128 -``` - -### Profiling and CI - -Profiling documentation, feature selection, benchmark dispatch, and CI coverage have been updated for the canonical adaptive fp128 one-hot family. - -The profiler reports the actual A/B/D dimensions and matrix ranks selected at each fold, making adaptive schedule choices directly observable. - -## Scope and limitations - -This PR supports adaptive dimensions for direct fp128 one-hot and dense schedules. - -The following paths remain on their existing uniform-D configurations: - -- fp32 and fp64 presets -- recursive setup offloading -- distributed/multi-chunk proving -- heterogeneous multi-group roots - -In particular, adaptive dimensions and recursive setup offloading are not yet combined. Recursive and distributed fp128 one-hot configurations continue to use their existing D64 catalogs. - -## Compatibility - -This is an intentional breaking configuration and generated-catalog change. - -Users of the old fp128 D128/D256 one-hot generated families or the `fp128_mixed_dim_onehot` names should migrate to: - -```rust -akita_config::proof_optimized::fp128::OneHot -``` - -Standalone direct fp128 use should select `fp128::OneHot` or `fp128::Dense`. - -## Validation - -The implementation includes coverage for: - -- Adaptive policy validation. -- A-dimension monotonicity. -- Independent B/D rank minimization. -- Rank greater than one when no candidate reaches rank one. -- Uniform suffix enforcement. -- Generated-row expansion and replay. -- Catalog identity drift. -- Planner/generated schedule parity. -- Deterministic candidate selection. -- Honest proving and verification. -- Wrong openings and commitment/proof tampering. -- Malformed or unsupported dimensions. -- Setup-capacity validation. -- Preservation of existing uniform planner paths. - -Documentation guardrails and generated-catalog consistency checks pass. From ebe43af55176b94ee9dd8ca96acd1d639c238287 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Thu, 6 Aug 2026 17:00:23 -0700 Subject: [PATCH 12/24] fix(schedules): align adaptive grouped profiles --- crates/akita-config/src/lib.rs | 10 +- crates/akita-config/tests/basis_envelope.rs | 6 +- crates/akita-config/tests/runtime_fallback.rs | 33 +++-- crates/akita-pcs/benches/root_kernels.rs | 2 +- crates/akita-pcs/examples/profile/main.rs | 14 +-- .../akita-pcs/examples/transcript_schedule.rs | 2 +- crates/akita-pcs/src/scheme/tests/mod.rs | 6 +- crates/akita-pcs/src/scheme/tests/onehot.rs | 5 +- crates/akita-pcs/tests/akita_e2e.rs | 35 +++--- .../akita-pcs/tests/batched_aggregated_e2e.rs | 6 +- crates/akita-pcs/tests/common/mod.rs | 24 ++++ .../tests/heterogeneous_prove_e2e.rs | 2 +- crates/akita-pcs/tests/setup.rs | 12 +- crates/akita-pcs/tests/support/mod.rs | 6 + .../akita-planner/src/generated_families.rs | 32 +++-- crates/akita-planner/src/planner.rs | 36 +++++- crates/akita-planner/src/schedule_params.rs | 107 +++++++--------- .../akita-prover/src/compute/requirements.rs | 2 +- .../akita-prover/src/protocol/core/tests.rs | 6 +- .../evaluation_trace/tests.rs | 11 +- crates/akita-prover/tests/dispatch_dim.rs | 14 ++- .../akita-prover/tests/orchestration_dim.rs | 6 +- .../akita-schedules/src/generated/expand.rs | 32 +++-- .../src/generated/fp128_dense_precommitted.rs | 12 +- .../src/generated/fp128_onehot.rs | 119 +++++++++++++++++- .../generated/fp128_onehot_precommitted.rs | 13 +- crates/akita-schedules/src/generated/walk.rs | 1 + crates/akita-schedules/src/group_batch.rs | 3 +- crates/akita-verifier/src/stages/stage3.rs | 9 +- 29 files changed, 387 insertions(+), 179 deletions(-) diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index e03a0681d..aad5ebfcb 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -771,11 +771,17 @@ mod precommit_tests { ) .expect("precommitted group params"); let precommitted = akita_types::CommittedGroupProfile::from_params(group, ¶ms); + let scalar_schedule = + fp128::OneHot::runtime_schedule(AkitaScheduleLookupKey::single(group)) + .expect("generated scalar schedule"); + let scalar_root = akita_types::CommittedGroupProfile::from_params( + group, + &scalar_schedule.root.params.final_group.commitment, + ); + assert_eq!(precommitted, scalar_root); 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, 2); assert_ne!(precommitted.inner_commit_matrix.output_rank(), 0); assert_ne!(precommitted.outer_commit_matrix.output_rank(), 0); } 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/runtime_fallback.rs b/crates/akita-config/tests/runtime_fallback.rs index d2e97cf84..7614251f5 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 @@ -328,7 +329,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)| { @@ -367,7 +368,7 @@ fn policy_bridge_matches_cfg_hooks() { } #[test] -fn adaptive_dense_rejects_multi_group_roots() { +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; @@ -384,7 +385,7 @@ fn adaptive_dense_rejects_multi_group_roots() { precommitteds: vec![CommittedGroupProfile::from_params(pre_group, &pre_params)], }; let precommitted_honest_fold_policies = vec![Cfg::root_honest_fold_policy()]; - let error = find_schedule( + let planned = find_schedule( &key, Cfg::root_honest_fold_policy(), &precommitted_honest_fold_policies, @@ -392,11 +393,25 @@ fn adaptive_dense_rejects_multi_group_roots() { Cfg::ring_challenge_config, Cfg::fold_challenge_shape_at_level, ) - .expect_err("adaptive dense multi-group planning is deferred"); - assert!(matches!( - error, - akita_field::AkitaError::UnsupportedSchedule(_) - )); + .expect("adaptive dense grouped schedule"); + planned + .schedule + .validate_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] diff --git a/crates/akita-pcs/benches/root_kernels.rs b/crates/akita-pcs/benches/root_kernels.rs index edfedbe24..4266bc49d 100644 --- a/crates/akita-pcs/benches/root_kernels.rs +++ b/crates/akita-pcs/benches/root_kernels.rs @@ -15,7 +15,7 @@ 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; diff --git a/crates/akita-pcs/examples/profile/main.rs b/crates/akita-pcs/examples/profile/main.rs index ca4d11050..1b875fe2b 100644 --- a/crates/akita-pcs/examples/profile/main.rs +++ b/crates/akita-pcs/examples/profile/main.rs @@ -40,23 +40,13 @@ fn main() { std::process::exit(2); } - let default_nv = if cfg!(feature = "profile-onehot-fp128-d64") { - 32 - } else { - 32 - }; let nv: usize = env::var("AKITA_NUM_VARS") .ok() .and_then(|s| s.parse().ok()) - .unwrap_or(default_nv); + .unwrap_or(32); let num_polys = env_usize("AKITA_NUM_POLYS", 1); - let default_mode = if cfg!(feature = "profile-onehot-fp128-d64") { - "onehot_fp128" - } else { - "onehot_fp128" - }; - let mode = env::var("AKITA_MODE").unwrap_or_else(|_| default_mode.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) { 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/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 1ff61c025..79bf7c353 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; diff --git a/crates/akita-pcs/tests/akita_e2e.rs b/crates/akita-pcs/tests/akita_e2e.rs index adab58668..ab435830b 100644 --- a/crates/akita-pcs/tests/akita_e2e.rs +++ b/crates/akita-pcs/tests/akita_e2e.rs @@ -432,11 +432,11 @@ fn chunked_multi_chunk_prove_verify() { } #[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; + type Cfg = fp128::Dense; const D: usize = Cfg::D; let layout = singleton_layout::(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,7 +623,7 @@ 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; + type Cfg = fp128::OneHot; const D: usize = Cfg::D; const NV: usize = 20; @@ -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,7 +830,7 @@ 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; + type Cfg = fp128::OneHot; const D: usize = Cfg::D; let nv = ONEHOT_TEST_NV; @@ -929,10 +929,9 @@ 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; + // NV=20 is large enough to include a recursive suffix in the generated + // adaptive two-claim schedule. + type Cfg = fp128::OneHot; const D: usize = Cfg::D; const NV: usize = 20; @@ -1071,7 +1070,7 @@ 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; + type Cfg = fp128::OneHot; const D: usize = Cfg::D; let nv = ONEHOT_TEST_NV; diff --git a/crates/akita-pcs/tests/batched_aggregated_e2e.rs b/crates/akita-pcs/tests/batched_aggregated_e2e.rs index fe51a01be..e6b6c4595 100644 --- a/crates/akita-pcs/tests/batched_aggregated_e2e.rs +++ b/crates/akita-pcs/tests/batched_aggregated_e2e.rs @@ -61,7 +61,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 +152,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 +275,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 0b753e3c8..167ffae5d 100644 --- a/crates/akita-pcs/tests/common/mod.rs +++ b/crates/akita-pcs/tests/common/mod.rs @@ -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], 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/setup.rs b/crates/akita-pcs/tests/setup.rs index 4425163ca..5684c6c03 100644 --- a/crates/akita-pcs/tests/setup.rs +++ b/crates/akita-pcs/tests/setup.rs @@ -593,16 +593,16 @@ macro_rules! preset_module { } 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/support/mod.rs b/crates/akita-pcs/tests/support/mod.rs index 9d0f7ee97..3f67a7ca2 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() @@ -139,6 +141,10 @@ where Envelope::fold_challenge_shape_at_level(inputs) } + fn selection_policy() -> akita_schedules::SelectionPolicyId { + Envelope::selection_policy() + } + fn sis_modulus_profile() -> SisModulusProfileId { Envelope::sis_modulus_profile() } diff --git a/crates/akita-planner/src/generated_families.rs b/crates/akita-planner/src/generated_families.rs index c373f13e2..2f596e99f 100644 --- a/crates/akita-planner/src/generated_families.rs +++ b/crates/akita-planner/src/generated_families.rs @@ -375,7 +375,8 @@ fn precommitted_profiles( } } - if 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::() || std::any::TypeId::of::() == std::any::TypeId::of::() { push_unique_profile( @@ -387,13 +388,17 @@ fn precommitted_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::() + || 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::() + || std::any::TypeId::of::() == std::any::TypeId::of::() + { push_unique_profile( &mut profiles, standalone_precommit_profile::(PolynomialGroupLayout::new(15, 2))?, @@ -416,7 +421,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) @@ -424,9 +428,15 @@ 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_onehot_catalog_key()?); + keys.extend(onehot_group_batch_test_keys::()?); + return Ok(keys); + } 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.push(heterogeneous_onehot_catalog_key()?); keys.extend(onehot_group_batch_test_keys::()?); return Ok(keys); } @@ -473,14 +483,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), @@ -729,7 +739,7 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ scalar_keys: FP128_ONEHOT_KEYS, regen: regen_fp128_onehot, regen_group_batch: regen_group_batch::, - emit_group_batch: false, + emit_group_batch: true, group_batch_keys: group_batch_keys::, table_backed: table_backed::, policy: family_policy::, diff --git a/crates/akita-planner/src/planner.rs b/crates/akita-planner/src/planner.rs index 3f9d2f81c..7aa49d57c 100644 --- a/crates/akita-planner/src/planner.rs +++ b/crates/akita-planner/src/planner.rs @@ -555,11 +555,39 @@ pub fn find_schedule( policy.ring_dimension_schedule_mode, crate::RingDimensionScheduleMode::AdaptiveDimension { .. } ) { - validate_adaptive_dimension_schedule_request(key, policy)?; - return mixed_search::find_schedule( - key.final_group, - policy, + if key.precommitteds.is_empty() { + validate_adaptive_dimension_schedule_request(key, policy)?; + return mixed_search::find_schedule( + key.final_group, + policy, + final_honest_fold_policy, + ring_challenge_config, + fold_challenge_shape_at_level, + ); + } + + // Adaptive search currently optimizes scalar roots. Grouped roots keep + // every already-committed A/B profile exact and plan the combined + // opening at the policy's uniform suffix dimension. + 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, fold_challenge_shape_at_level, ); diff --git a/crates/akita-planner/src/schedule_params.rs b/crates/akita-planner/src/schedule_params.rs index daf621520..717aae80a 100644 --- a/crates/akita-planner/src/schedule_params.rs +++ b/crates/akita-planner/src/schedule_params.rs @@ -511,10 +511,11 @@ 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. +/// For adaptive policies, the profile is the A/B geometry of the canonical +/// scalar schedule's final root group. This keeps `commit_group` and a later +/// scalar opening on the same generated row when global planning selects +/// different dimensions from a locally minimized commitment. Uniform policies +/// retain their direct, group-local minimization for specialized catalogs. pub fn derive_standalone_precommit_profile( key: PolynomialGroupLayout, policy: &PlannerPolicy, @@ -523,10 +524,28 @@ pub fn derive_standalone_precommit_profile( fold_challenge_shape_at_level: impl Fn(AkitaScheduleInputs) -> TensorChallengeShape, ) -> Result { key.validate()?; + let schedule_key = AkitaScheduleLookupKey::single(key); + if matches!( + policy.ring_dimension_schedule_mode, + crate::RingDimensionScheduleMode::AdaptiveDimension { .. } + ) { + let planned = crate::planner::find_schedule( + &schedule_key, + honest_fold_policy, + &[], + policy, + ring_challenge_config, + fold_challenge_shape_at_level, + )?; + return Ok(CommittedGroupProfile::from_params( + key, + &planned.schedule.root.params.final_group.commitment, + )); + } + let mut direct_policy = policy.direct_only(); direct_policy.basis_range = (direct_policy.basis_range.0, direct_policy.basis_range.0); 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()))?; @@ -537,65 +556,35 @@ pub fn derive_standalone_precommit_profile( }); 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); - - let dimension_candidates = match direct_policy.ring_dimension_schedule_mode { - crate::RingDimensionScheduleMode::UniformDimension { ring_dimension } => vec![ - akita_schedules::planner_support::RingDimensionCandidate::Fixed( - CommitmentRingDims::uniform(ring_dimension), - ), - ], - crate::RingDimensionScheduleMode::AdaptiveDimension { - potential_a_dimensions, - potential_b_dimensions, - potential_d_dimensions, - .. - } => potential_a_dimensions - .iter() - .copied() - .map( - |inner| akita_schedules::planner_support::RingDimensionCandidate::Adaptive { - inner, - outer_dimensions: potential_b_dimensions, - opening_dimensions: potential_d_dimensions, - ceiling: CommitmentRingDims::uniform(direct_policy.uniform_ring_dimension), - }, - ) - .collect(), + let crate::RingDimensionScheduleMode::UniformDimension { ring_dimension } = + direct_policy.ring_dimension_schedule_mode + else { + unreachable!("adaptive precommit planning returns above"); }; for candidate_log_basis in min_log_basis..=max_log_basis { - for dimensions in dimension_candidates.iter().copied() { - let Ok(ring_challenge_cfg) = ring_challenge_config(dimensions.inner()) else { - continue; - }; - let alpha = (dimensions.inner() 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, - requested_fold_shape, - 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(ring_dimension), + ); + let ring_challenge_cfg = ring_challenge_config(ring_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, + requested_fold_shape, + 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!( 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 ba443aa47..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::D64Dense; +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 5f391358c..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_d64_schedule() { - let schedule = schedule::(16); - validate_schedule_ring_dims(&schedule).expect("D64 schedule"); - assert_schedule_geometry(&schedule, 64); +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 1558a2e11..eb671288b 100644 --- a/crates/akita-prover/tests/orchestration_dim.rs +++ b/crates/akita-prover/tests/orchestration_dim.rs @@ -41,7 +41,7 @@ fn batched_selection_preserves_typed_schedule_topology() { #[test] fn role_dispatch_rejects_wrong_inner_dimension() { - let schedule = fp128::D64Dense::runtime_schedule(AkitaScheduleLookupKey::single( + let schedule = fp128::Dense::runtime_schedule(AkitaScheduleLookupKey::single( PolynomialGroupLayout::singleton(16), )) .expect("runtime schedule"); @@ -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/src/generated/expand.rs b/crates/akita-schedules/src/generated/expand.rs index 2887ef59c..7a7160796 100644 --- a/crates/akita-schedules/src/generated/expand.rs +++ b/crates/akita-schedules/src/generated/expand.rs @@ -663,13 +663,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(), @@ -757,17 +757,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(|| { @@ -778,7 +784,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"))?; @@ -824,7 +830,7 @@ impl GeneratedCommittedGroup { n_b, outer_width, b_bucket, - ring_d, + dimensions.d_b(), )?, open_commit_matrix: OpenCommitMatrixParams::try_new( sis_policy, @@ -833,7 +839,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) diff --git a/crates/akita-schedules/src/generated/fp128_dense_precommitted.rs b/crates/akita-schedules/src/generated/fp128_dense_precommitted.rs index 8ff9c43c2..a8e618e40 100644 --- a/crates/akita-schedules/src/generated/fp128_dense_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_dense_precommitted.rs @@ -6,10 +6,10 @@ use super::{ #[rustfmt::skip] pub(crate) static FP128_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: 64, 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: 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 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), 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 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), 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 } }, 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(16, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 64, 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, 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 } }, num_digits_inner: 43, inner_output_rank: 1, inner_coeff_linf_bound: 65535, 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: 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 } }, num_digits_inner: 43, inner_output_rank: 1, inner_coeff_linf_bound: 65535, 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: 8, 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 } }, num_digits_inner: 43, inner_output_rank: 1, inner_coeff_linf_bound: 65535, 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: 16, 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 } }, num_digits_inner: 43, inner_output_rank: 1, inner_coeff_linf_bound: 65535, 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: 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 } }, num_digits_inner: 43, inner_output_rank: 1, inner_coeff_linf_bound: 65535, 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: 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 } }, num_digits_inner: 43, inner_output_rank: 1, inner_coeff_linf_bound: 65535, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, ]; diff --git a/crates/akita-schedules/src/generated/fp128_onehot.rs b/crates/akita-schedules/src/generated/fp128_onehot.rs index 0de64a292..1c7b03b7c 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot.rs @@ -84,6 +84,25 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ ], terminal: GeneratedTerminalFold { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1992, 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(16, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, + commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 64, 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: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(15, 2), num_live_ring_elements_per_claim: 128, num_positions_per_block: 16, num_live_blocks: 8, log_basis_inner: 3, num_digits_inner: 43, 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, 1, 688, 65535, 256), 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, 2752, 7, 64) }, num_digits_fold: 3, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 16, 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 } } }, + ], + 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: 20989, 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 }, + ], + 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: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, @@ -128,6 +147,24 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ ], 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(20, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, + 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 } } }, + precommitted_groups: &[ + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 2), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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, 1376, 7, 64) }, num_digits_fold: 2, 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 } } }, + ], + 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: 8854, positions_per_block: 1024, live_blocks: 9 }, 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: 5400, 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::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(20, 2), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, @@ -144,6 +181,24 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ ], 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(20, 2), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, + 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 } } }, + precommitted_groups: &[ + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + ], + 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: 10634, positions_per_block: 1024, live_blocks: 11 }, 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: 5784, 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::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(20, 4), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, @@ -160,6 +215,45 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ ], 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(20, 4), num_digits_inner: 1, num_digits_fold: 3, challenge: GeneratedRootFinalChallenge::Flat, + 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 } } }, + precommitted_groups: &[ + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + ], + 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: 20028, 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 }, + ], + 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(20, 4), num_digits_inner: 1, num_digits_fold: 3, challenge: GeneratedRootFinalChallenge::Flat, + 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 } } }, + precommitted_groups: &[ + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + ], + 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: 23203, 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(28, 1), num_digits_inner: 1, num_digits_fold: 2, challenge: GeneratedRootFinalChallenge::Flat, @@ -231,6 +325,27 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ ], 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, 2), num_digits_inner: 1, num_digits_fold: 4, challenge: GeneratedRootFinalChallenge::Flat, + 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 } } }, + precommitted_groups: &[ + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 1), num_live_ring_elements_per_claim: 256, num_positions_per_block: 32, 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, 1, 32, 8191, 256), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 1), num_live_ring_elements_per_claim: 256, num_positions_per_block: 32, 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, 1, 32, 8191, 256), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + ], + 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: 798367, positions_per_block: 8192, live_blocks: 98 }, 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: 58749, positions_per_block: 2048, live_blocks: 29 }, 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: 16371, 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(32, 4), num_digits_inner: 1, num_digits_fold: 3, challenge: GeneratedRootFinalChallenge::Flat, @@ -358,6 +473,6 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated 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: 3458533356553718245, - key_count: 19, - key_digest: 4526130598428523590, + key_count: 25, + key_digest: 9179620393641471586, }; diff --git a/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs index 5740c5f8d..f0a71c3e8 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs @@ -6,10 +6,11 @@ use super::{ #[rustfmt::skip] pub(crate) static FP128_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 }, + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), 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: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, 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: 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 } }, 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: 16, 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 } }, 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, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 32, 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 } }, 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: 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 } }, 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, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 64, 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 } }, 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(20, 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 } }, 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/walk.rs b/crates/akita-schedules/src/generated/walk.rs index f6c2b320a..f38edc50a 100644 --- a/crates/akita-schedules/src/generated/walk.rs +++ b/crates/akita-schedules/src/generated/walk.rs @@ -76,6 +76,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 diff --git a/crates/akita-schedules/src/group_batch.rs b/crates/akita-schedules/src/group_batch.rs index 9c95bce09..15857554d 100644 --- a/crates/akita-schedules/src/group_batch.rs +++ b/crates/akita-schedules/src/group_batch.rs @@ -160,6 +160,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 @@ -178,7 +179,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-verifier/src/stages/stage3.rs b/crates/akita-verifier/src/stages/stage3.rs index 4e287ba3a..41efd99be 100644 --- a/crates/akita-verifier/src/stages/stage3.rs +++ b/crates/akita-verifier/src/stages/stage3.rs @@ -347,7 +347,12 @@ mod tests { 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 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 @@ -366,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"); From 0d3450537e0b5e631f9ecef16c015b9f9c48470a Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Fri, 7 Aug 2026 00:26:19 -0700 Subject: [PATCH 13/24] fix(ci): simplify benchmark workload labels --- book/src/usage/profiling.md | 2 +- scripts/profile_bench_report.py | 27 +++------------ scripts/profile_trace_spans.py | 3 +- scripts/tests/test_profile_bench_report.py | 39 +++++++++++++++++++++- 4 files changed, 44 insertions(+), 27 deletions(-) diff --git a/book/src/usage/profiling.md b/book/src/usage/profiling.md index dfc7ef176..868b167b9 100644 --- a/book/src/usage/profiling.md +++ b/book/src/usage/profiling.md @@ -28,7 +28,7 @@ normal release link look like a verifier regression. 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, tensor, and multi-chunk companion presets +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. diff --git a/scripts/profile_bench_report.py b/scripts/profile_bench_report.py index 5f46315e7..120a2ae84 100644 --- a/scripts/profile_bench_report.py +++ b/scripts/profile_bench_report.py @@ -1702,10 +1702,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": @@ -1717,24 +1717,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 @@ -1744,9 +1728,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) 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..456dcc4fa 100644 --- a/scripts/tests/test_profile_bench_report.py +++ b/scripts/tests/test_profile_bench_report.py @@ -407,10 +407,47 @@ 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_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_d64_multi_chunk_w4r2", + "num_vars": 32, + "num_polys": 1, + "exit_code": 0, + "planned_levels": [ + {"level": 0, "d_a": 64, "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 From 43967be6150fd6ecf93b794dfb519587fcf5f960 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Fri, 7 Aug 2026 00:51:41 -0700 Subject: [PATCH 14/24] fix(ci): use adaptive catalog for direct multi-group benchmark --- .github/workflows/profile-bench.yml | 4 +- book/src/usage/profiling.md | 2 +- crates/akita-pcs/examples/profile/modes.rs | 41 ++++++++++++++----- crates/akita-pcs/examples/profile/workload.rs | 6 +-- scripts/check_profile_ci_features.sh | 1 + scripts/profile_bench_report.py | 3 ++ scripts/tests/test_profile_bench_report.py | 20 +++++++++ specs/profile-bench-coverage-matrix.md | 4 +- 8 files changed, 63 insertions(+), 18 deletions(-) diff --git a/.github/workflows/profile-bench.yml b/.github/workflows/profile-bench.yml index 05733bdb5..8cedb80ec 100644 --- a/.github/workflows/profile-bench.yml +++ b/.github/workflows/profile-bench.yml @@ -71,9 +71,9 @@ jobs: onehot_fp32_d128:28:1 onehot_fp64_d128:28:1 onehot_fp128:32:1 - - name: 4-multi-group-recursive-direct + - 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 diff --git a/book/src/usage/profiling.md b/book/src/usage/profiling.md index 868b167b9..d3bccf8ef 100644 --- a/book/src/usage/profiling.md +++ b/book/src/usage/profiling.md @@ -78,7 +78,7 @@ Committed-fold A-role pricing (every cell folds securely): | `onehot_fp64_d128` | 28 | 1 | `direct` | | `dense_fp128` | 24 | 1 | `direct` | | `onehot_fp128` | 32 | 1 | `direct` | -| `onehot_fp128_d64_multi_group_recursive` | 32 | 4 | `direct` | +| `onehot_fp128_multi_group` | 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` | diff --git a/crates/akita-pcs/examples/profile/modes.rs b/crates/akita-pcs/examples/profile/modes.rs index 8655e8fd5..ad13b822c 100644 --- a/crates/akita-pcs/examples/profile/modes.rs +++ b/crates/akita-pcs/examples/profile/modes.rs @@ -2,8 +2,8 @@ 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; @@ -183,6 +183,10 @@ const PROFILE_CI_MODES: &[ProfileMode] = &[ name: "onehot_fp128", run: run_profile_onehot_fp128, }, + ProfileMode { + 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, @@ -223,6 +227,10 @@ const PROFILE_ALL_MODES: &[ProfileMode] = &[ name: "onehot_fp128", run: run_profile_onehot_fp128, }, + ProfileMode { + 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, @@ -288,6 +296,7 @@ fn profile_modes() -> &'static [ProfileMode] { /// Modes registered for explicit `AKITA_MODE=…` runs but omitted from `all`. #[cfg(not(feature = "profile-onehot-fp128-d64"))] const EXCLUDED_FROM_ALL_SWEEP: &[&str] = &[ + "onehot_fp128_multi_group", "onehot_fp128_d64_multi_chunk_w2r2", "onehot_fp128_d64_multi_chunk_w4r2", "onehot_fp128_d64_multi_chunk_w8r2", @@ -383,14 +392,11 @@ fn run_profile_onehot_fp128(nv: usize, num_polys: usize) { 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, @@ -408,9 +414,24 @@ fn run_recursive_multi_group_mode< run_recursive_multi_group_onehot::(label, 16, 32, 2); } +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(nv: usize, num_polys: usize) { type Cfg = fp128::D64OneHot; - run_recursive_multi_group_mode::<{ Cfg::D }, Cfg>( + run_multi_group_mode::<{ Cfg::D }, Cfg>( "onehot_fp128_d64_multi_group_recursive", "recursive setup", nv, @@ -426,7 +447,7 @@ fn run_profile_onehot_fp128_d64_multi_group_recursive_multi_chunk_w8r2( // 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>( + run_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", nv, diff --git a/crates/akita-pcs/examples/profile/workload.rs b/crates/akita-pcs/examples/profile/workload.rs index e311c80cd..e0b7c30bf 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, diff --git a/scripts/check_profile_ci_features.sh b/scripts/check_profile_ci_features.sh index b2399fd8a..cadcd3a26 100755 --- a/scripts/check_profile_ci_features.sh +++ b/scripts/check_profile_ci_features.sh @@ -21,6 +21,7 @@ MODE_FEATURE = { "onehot_fp64_d128": "schedules-fp64-d128-onehot", "dense_fp128": "schedules-fp128-dense", "onehot_fp128": "schedules-fp128-onehot", + "onehot_fp128_multi_group": "schedules-fp128-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", diff --git a/scripts/profile_bench_report.py b/scripts/profile_bench_report.py index 120a2ae84..7b29162b8 100644 --- a/scripts/profile_bench_report.py +++ b/scripts/profile_bench_report.py @@ -93,6 +93,9 @@ class CaseMetadata: "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "mixed D256 to D64" ), "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": CaseMetadata( "fp128", "onehot", "multi-group one-hot", "D64 recursive multi-group" ), diff --git a/scripts/tests/test_profile_bench_report.py b/scripts/tests/test_profile_bench_report.py index 456dcc4fa..cc7723b4b 100644 --- a/scripts/tests/test_profile_bench_report.py +++ b/scripts/tests/test_profile_bench_report.py @@ -428,6 +428,26 @@ def test_adaptive_case_label_omits_ring_dimensions_and_mixed_dimension_config(se 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 diff --git a/specs/profile-bench-coverage-matrix.md b/specs/profile-bench-coverage-matrix.md index 46d5810aa..b3ebc1557 100644 --- a/specs/profile-bench-coverage-matrix.md +++ b/specs/profile-bench-coverage-matrix.md @@ -57,8 +57,8 @@ 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_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_d64_multi_group_recursive` | fp128 | 1-of-256 one-hot batched multi-group | 32 | 4 | D64 recursive multi-group | `recursive` | Recursive setup-product coverage using the dedicated recursive companion catalog. | | `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. | From bbd5f9a141f0080d8663189dfad9a878b5c2b810 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Fri, 7 Aug 2026 09:15:36 -0700 Subject: [PATCH 15/24] fix(planner): align adaptive search with review --- book/src/usage/profiling.md | 4 +- crates/akita-config/src/lib.rs | 18 +- crates/akita-config/src/proof_optimized.rs | 5 +- .../akita-config/src/proof_optimized/fp128.rs | 123 +------- crates/akita-pcs/Cargo.toml | 4 +- crates/akita-pcs/examples/profile/main.rs | 6 +- crates/akita-pcs/examples/profile/modes.rs | 24 +- crates/akita-planner/src/lib.rs | 4 +- crates/akita-planner/src/planner.rs | 11 +- crates/akita-planner/src/schedule_params.rs | 287 +----------------- .../src/schedule_params/candidate.rs | 6 +- .../schedule_params/candidate/setup_prefix.rs | 59 ---- .../src/schedule_params/mixed_search.rs | 10 +- .../src/schedule_params/objective.rs | 2 +- .../src/schedule_params/suffix_dp.rs | 3 +- .../akita-planner/src/test/schedule_params.rs | 128 +++++--- .../akita-planner/src/test/unpruned_search.rs | 11 +- crates/akita-schedules/src/candidate.rs | 15 +- .../src/generated/fp128_dense.rs | 40 +-- .../src/generated/fp128_onehot.rs | 171 +++++------ .../generated/fp128_onehot_precommitted.rs | 12 +- crates/akita-schedules/src/generated/walk.rs | 12 +- crates/akita-schedules/src/lib.rs | 4 +- crates/akita-schedules/src/runtime.rs | 232 +++++++++++--- crates/akita-types/src/dispatch/mod.rs | 18 ++ crates/akita-types/src/lib.rs | 6 +- crates/akita-types/src/sis/ajtai_key.rs | 34 ++- crates/akita-types/src/sis/mod.rs | 10 +- .../2026-Q3/group-local-opening-points.md | 2 +- specs/mixed-ring-dimension-per-level.md | 53 ++-- specs/profile-bench-coverage-matrix.md | 16 +- 31 files changed, 548 insertions(+), 782 deletions(-) diff --git a/book/src/usage/profiling.md b/book/src/usage/profiling.md index d3bccf8ef..ebaebb52b 100644 --- a/book/src/usage/profiling.md +++ b/book/src/usage/profiling.md @@ -8,7 +8,7 @@ traces, and the CI benchmark matrix. ```bash 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 @@ -60,7 +60,7 @@ Disable parallel while retaining the same pruned workload: ```bash 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 diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index 83953f861..968c5bd76 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -711,25 +711,21 @@ mod fp128_policy_tests { let dense = fp128::Dense::runtime_schedule(AkitaScheduleLookupKey::single(key)) .expect("adaptive dense schedule"); - let onehot = fp128::best_onehot_schedule(key) - .expect("selector should resolve onehot schedules") - .expect("selector should find a generated onehot schedule"); + let onehot = fp128::OneHot::runtime_schedule(AkitaScheduleLookupKey::single(key)) + .expect("adaptive onehot schedule"); assert_eq!(dense.initial_witness_len(), 1usize << 32); - assert_eq!(onehot.schedule.initial_witness_len(), 1usize << 32); - assert!(onehot.preset.is_onehot()); + 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); } } diff --git a/crates/akita-config/src/proof_optimized.rs b/crates/akita-config/src/proof_optimized.rs index 8f6cc53a5..0e5aefd67 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 { diff --git a/crates/akita-config/src/proof_optimized/fp128.rs b/crates/akita-config/src/proof_optimized/fp128.rs index 9d0d52402..ad60d1dec 100644 --- a/crates/akita-config/src/proof_optimized/fp128.rs +++ b/crates/akita-config/src/proof_optimized/fp128.rs @@ -10,8 +10,8 @@ pub type Field = Prime128OffsetA7F7; #[derive(Clone, Copy, Debug, Default)] pub struct D64Dense; -/// Default dense preset with D256 setup generation and planner-selected -/// per-level commitment dimensions. +/// 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 Dense; @@ -34,8 +34,8 @@ pub struct D64OneHotK16; #[derive(Clone, Copy, Debug, Default)] pub struct D256OneHot; -/// Default binary onehot preset with D256 setup generation 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. @@ -95,7 +95,7 @@ impl_proof_optimized_preset!( fold_norms = akita_types::sis::FoldWitnessNorms::bounded(3, 64), schedules = ("schedules-fp128-dense", "fp128_dense", fp128_dense_table), ring_dimension_schedule_mode = akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { - num_search_levels: 2, + 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, @@ -143,7 +143,7 @@ impl_proof_optimized_preset!( fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 1), schedules = ("schedules-fp128-onehot", "fp128_onehot", fp128_onehot_table), ring_dimension_schedule_mode = akita_schedules::RingDimensionScheduleMode::AdaptiveDimension { - num_search_levels: 2, + 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, @@ -188,114 +188,3 @@ impl_multi_chunk_companion!( "schedules-fp128-d64-dense-multi-chunk", fp128_d64_dense_multi_chunk_table ); - -/// Concrete fp128 preset selected by a schedule-family query. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Fp128Preset { - /// Dense preset with adaptive per-level ring dimensions. - Dense, - /// Binary onehot preset with adaptive per-level ring dimensions. - OneHot, -} - -impl Fp128Preset { - /// Setup-generation ring dimension used by this preset. - pub const fn ring_dimension(self) -> usize { - match self { - Self::Dense | Self::OneHot => 256, - } - } - - /// Whether this preset is onehot-oriented. - pub const fn is_onehot(self) -> bool { - matches!(self, Self::OneHot) - } - - /// Stable human-readable preset name. - pub const fn name(self) -> &'static str { - match self { - Self::Dense => "Dense", - Self::OneHot => "OneHot", - } - } -} - -/// 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 onehot fp128 preset for a schedule lookup key. -/// -/// A genuine planner failure propagates as an error; for any valid key every -/// supported preset yields a schedule, so the best available one is 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::OneHot, - key, - )?])) -} diff --git a/crates/akita-pcs/Cargo.toml b/crates/akita-pcs/Cargo.toml index f6f83a5db..d853d9fde 100644 --- a/crates/akita-pcs/Cargo.toml +++ b/crates/akita-pcs/Cargo.toml @@ -57,10 +57,10 @@ profile-ci = [ "akita-config/schedules-fp128-d64-onehot-multi-chunk-w2r2", "akita-config/schedules-fp128-d64-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-onehot"] +profile-onehot-fp128 = ["akita-config/schedules-fp128-onehot"] schedules-fp128-d64-dense-multi-chunk = [ "akita-config/schedules-fp128-d64-dense-multi-chunk", ] diff --git a/crates/akita-pcs/examples/profile/main.rs b/crates/akita-pcs/examples/profile/main.rs index 1b875fe2b..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; @@ -99,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); @@ -107,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 ad13b822c..565cf0e2f 100644 --- a/crates/akita-pcs/examples/profile/modes.rs +++ b/crates/akita-pcs/examples/profile/modes.rs @@ -1,4 +1,4 @@ -#![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::{ @@ -164,16 +164,16 @@ 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", @@ -217,7 +217,7 @@ 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", @@ -281,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")] { @@ -294,7 +294,7 @@ 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_multi_group", "onehot_fp128_d64_multi_chunk_w2r2", @@ -551,7 +551,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 @@ -570,7 +570,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) { @@ -586,15 +586,15 @@ 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", - "profile-onehot-fp128-d64 only supports AKITA_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(nv, num_polys); } diff --git a/crates/akita-planner/src/lib.rs b/crates/akita-planner/src/lib.rs index 2e589af3d..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`. diff --git a/crates/akita-planner/src/planner.rs b/crates/akita-planner/src/planner.rs index 0c0923be1..baf59e818 100644 --- a/crates/akita-planner/src/planner.rs +++ b/crates/akita-planner/src/planner.rs @@ -18,8 +18,7 @@ use akita_schedules::planner_support::{sis_key_at_dimension, RingDimensionCandid use crate::schedule_params::{ derive_optimal_suffix_schedule, materialize_candidate_schedule, mixed_search, - select_complete_candidate, validate_policy, RingChallengeConfigFn, ScheduleMemo, SuffixCtx, - SuffixState, + select_complete_candidate, RingChallengeConfigFn, ScheduleMemo, SuffixCtx, SuffixState, }; use crate::PlannerPolicy; @@ -514,10 +513,10 @@ fn validate_adaptive_dimension_schedule_request( )); } if policy.selection_policy - != crate::SelectionPolicyId::MinAdaptiveARankDimensionThenSetupAndProof + != crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload { return Err(AkitaError::InvalidSetup( - "adaptive search requires MinAdaptiveARankDimensionThenSetupAndProof".into(), + "adaptive search requires MinSetupMatrixFieldElementsThenProofPayload".into(), )); } if policy.witness_chunk.uses_multi_chunk() { @@ -536,7 +535,7 @@ 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())?; if matches!( policy.ring_dimension_schedule_mode, @@ -633,7 +632,7 @@ pub fn find_schedule( crate::SelectionPolicyId::MinEstimatedProofPayload => { select_complete_candidate(active_policy, suffix.best_by_payload_per_lb.values())? } - crate::SelectionPolicyId::MinAdaptiveARankDimensionThenSetupAndProof => { + crate::SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload => { return Err(AkitaError::UnsupportedSchedule( "mixed ring-dimension selection is not supported for multi-group roots".to_string(), )); diff --git a/crates/akita-planner/src/schedule_params.rs b/crates/akita-planner/src/schedule_params.rs index 509ea80f0..1ea845ef6 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 @@ -20,10 +18,8 @@ use akita_types::sis::{ use akita_types::{ 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, + DecompositionParams, PlannedFoldSchedule, PolynomialGroupLayout, PrecommittedLevelParams, + WitnessLayout, }; use crate::PlannerPolicy; @@ -36,6 +32,10 @@ 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, @@ -46,30 +46,9 @@ pub(crate) use setup_score::{ }; pub(crate) use suffix_dp::{derive_optimal_suffix_schedule, ScheduleMemo, SuffixCtx, SuffixState}; -#[cfg(test)] -pub(crate) const MIXED_SEARCH_FOLD_LEVELS: usize = 2; #[cfg(test)] 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, -} - -#[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, -} - /// Explicit A/B/D dimensions admitted by mixed-D planner search. /// /// The planner policy's uniform ring dimension defines only the implicit @@ -115,7 +94,7 @@ impl RingDimensionSearchDomain { #[cfg(test)] pub(crate) fn validate_for_policy(&self, policy: &PlannerPolicy) -> Result<(), AkitaError> { - validate_policy(policy) + akita_schedules::planner_support::validate_policy(policy) } } @@ -158,155 +137,6 @@ impl ScheduleCandidate { self.setup_field_elements, ) } - - pub(crate) fn adaptive_a_rank_dimension_key( - &self, - num_search_levels: usize, - ) -> Vec<(usize, usize)> { - self.folds - .iter() - .take(num_search_levels) - .map(|fold| { - ( - fold.params.inner_commit_matrix.output_rank(), - fold.params.role_dims().d_a(), - ) - }) - .collect() - } - - pub(crate) fn adaptive_a_dimension_key(&self, num_search_levels: usize) -> Vec { - self.folds - .iter() - .take(num_search_levels) - .map(|fold| fold.params.role_dims().d_a()) - .collect() - } -} - -/// 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( @@ -323,100 +153,6 @@ pub(crate) fn candidate_schedule_descriptor_bytes( .canonical_descriptor_bytes()) } -pub(crate) fn select_adaptive_candidate( - candidates: Vec, - num_search_levels: usize, -) -> Result, AkitaError> { - let mut per_path = candidates - .into_iter() - .map(|candidate| { - let descriptor = candidate_schedule_descriptor_bytes(&candidate)?; - Ok(( - candidate.adaptive_a_dimension_key(num_search_levels), - MixedScore { - setup_field_elements: candidate.setup_field_elements, - proof_bytes: candidate.total_bytes, - }, - descriptor, - candidate, - )) - }) - .collect::, AkitaError>>()?; - per_path - .sort_by(|left, right| (&left.0, &left.1, &left.2).cmp(&(&right.0, &right.1, &right.2))); - per_path.dedup_by(|left, right| left.0 == right.0); - let mut winners = per_path - .into_iter() - .map(|(_, score, descriptor, candidate)| { - ( - candidate.adaptive_a_rank_dimension_key(num_search_levels), - score, - descriptor, - candidate, - ) - }) - .collect::>(); - winners.sort_by(|left, right| (&left.0, &left.1, &left.2).cmp(&(&right.0, &right.1, &right.2))); - Ok(winners - .into_iter() - .next() - .map(|(_, _, _, candidate)| candidate)) -} - -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> { - akita_schedules::planner_support::validate_policy(policy)?; - 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; @@ -487,7 +223,7 @@ pub fn derive_standalone_precommit_profile( let mut direct_policy = policy.direct_only(); 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()))?; @@ -529,11 +265,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; - #[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 0ec2e2dc7..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::{sis_key_at_dimension, RingDimensionCandidate}; +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/setup_prefix.rs b/crates/akita-planner/src/schedule_params/candidate/setup_prefix.rs index 10dec7fa3..6f1a30330 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, diff --git a/crates/akita-planner/src/schedule_params/mixed_search.rs b/crates/akita-planner/src/schedule_params/mixed_search.rs index b0b45fa4c..597a085d5 100644 --- a/crates/akita-planner/src/schedule_params/mixed_search.rs +++ b/crates/akita-planner/src/schedule_params/mixed_search.rs @@ -1,6 +1,7 @@ use std::collections::HashMap; use super::*; +use akita_schedules::planner_support::MAX_RECURSION_DEPTH; type MixedMemo = HashMap< ( @@ -301,7 +302,7 @@ pub(crate) fn find_schedule( let schedule_key = AkitaScheduleLookupKey::single(key); let crate::RingDimensionScheduleMode::AdaptiveDimension { - num_search_levels, + num_search_levels: _, uniform_suffix_dimension: _, potential_a_dimensions, potential_b_dimensions, @@ -319,7 +320,10 @@ pub(crate) fn find_schedule( inner: root_inner, outer_dimensions: potential_b_dimensions, opening_dimensions: potential_d_dimensions, - ceiling: CommitmentRingDims::uniform(policy.uniform_ring_dimension), + // The root has no preceding schedule level. Its only + // projection ceiling is its own A-native source ring; the + // config's uniform-D field is unrelated to adaptive search. + ceiling: CommitmentRingDims::uniform(root_inner), }; let alpha = root_dimensions.inner().trailing_zeros() as usize; let reduced_vars = key.num_vars().saturating_sub(alpha); @@ -409,7 +413,7 @@ pub(crate) fn find_schedule( } } - let Some(selected) = select_adaptive_candidate(complete, num_search_levels)? else { + let Some(selected) = select_complete_candidate(policy, &complete)?.cloned() else { return Err(AkitaError::UnsupportedSchedule(format!( "no mixed-D schedule with at least two folds for num_vars={}, num_polynomials={}", key.num_vars(), diff --git a/crates/akita-planner/src/schedule_params/objective.rs b/crates/akita-planner/src/schedule_params/objective.rs index 35c9077db..0f2c80e8e 100644 --- a/crates/akita-planner/src/schedule_params/objective.rs +++ b/crates/akita-planner/src/schedule_params/objective.rs @@ -35,7 +35,7 @@ pub(crate) fn complete_schedule_score( setup_field_elements: candidate.setup_field_elements, descriptor, }), - SelectionPolicyId::MinAdaptiveARankDimensionThenSetupAndProof => { + SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload => { Ok(CompleteScheduleScore::MixedDimension { setup_field_elements: candidate.setup_field_elements, proof_bytes: candidate.total_bytes, diff --git a/crates/akita-planner/src/schedule_params/suffix_dp.rs b/crates/akita-planner/src/schedule_params/suffix_dp.rs index 717d353cd..d7e4fee97 100644 --- a/crates/akita-planner/src/schedule_params/suffix_dp.rs +++ b/crates/akita-planner/src/schedule_params/suffix_dp.rs @@ -15,8 +15,9 @@ 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, + CandidateTerminalResponse, 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 diff --git a/crates/akita-planner/src/test/schedule_params.rs b/crates/akita-planner/src/test/schedule_params.rs index 91a1f761f..6df1fe26a 100644 --- a/crates/akita-planner/src/test/schedule_params.rs +++ b/crates/akita-planner/src/test/schedule_params.rs @@ -180,7 +180,7 @@ 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) @@ -314,6 +314,53 @@ fn uniform_suffix_dp_matches_unpruned_exact_cutover_search() { ); } +#[cfg(feature = "catalog-gen")] +#[test] +fn adaptive_frontier_matches_unpruned_l0_l1_search() { + use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, 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, + D256OneHot::root_honest_fold_policy(), + &domain, + D256OneHot::ring_challenge_config, + ) + .expect("frontier search"); + let unpruned = unpruned_search::find_schedule( + key, + &policy, + D256OneHot::root_honest_fold_policy(), + &domain, + D256OneHot::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 mixed_search_parallel_generation_is_descriptor_deterministic() { @@ -426,7 +473,7 @@ 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() { +fn mixed_search_rejects_an_advertised_unsupported_role_dimension() { use akita_config::{policy_of, proof_optimized::fp128::D512OneHot, CommitmentConfig}; let base_policy = policy_of::(); @@ -435,30 +482,20 @@ fn mixed_search_skips_an_unsupported_sis_candidate_and_keeps_its_sibling() { 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(), &domain, D512OneHot::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 adaptive_nv36_selects_minimum_rank_a_path() { +fn adaptive_nv36_minimizes_setup_before_proof_bytes() { use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; let base_policy = policy_of::(); @@ -507,22 +544,7 @@ fn adaptive_nv36_selects_minimum_rank_a_path() { .params .witness .role_dims(), - CommitmentRingDims { - inner: 256, - outer: 64, - opening: 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(), - 91_128 + d64 ); assert_eq!(rank_one_capped_root.inner_commit_matrix.output_rank(), 3); assert_eq!(selected_root.inner_commit_matrix.output_rank(), 1); @@ -536,7 +558,7 @@ fn adaptive_nv36_selects_minimum_rank_a_path() { 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" ); } @@ -576,7 +598,7 @@ fn mixed_search_requires_a_monotonic_d64_suffix_domain() { D256OneHot::ring_challenge_config, ) .unwrap_err(); - assert!(error.to_string().contains("must be at least suffix D64")); + assert!(error.to_string().contains("scheduled B dimension D32")); } #[cfg(feature = "catalog-gen")] @@ -643,17 +665,35 @@ 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::D64Dense}; - - let mut policy = policy_of::(); - let domain = RingDimensionSearchDomain::uniform(256).unwrap(); - policy.uniform_ring_dimension = 256; - policy.ring_dimension_schedule_mode = crate::RingDimensionScheduleMode::UniformDimension { - ring_dimension: 256, - }; - policy.selection_policy = crate::SelectionPolicyId::MinEstimatedProofPayload; +fn adaptive_root_domain_is_independent_of_uniform_config_dimension() { + use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; + + let domain = RingDimensionSearchDomain::new([ + CommitmentRingDims::uniform(64), + CommitmentRingDims { + inner: 256, + outer: 128, + opening: 128, + }, + ]) + .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, + D256OneHot::root_honest_fold_policy(), + &domain, + D256OneHot::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")] diff --git a/crates/akita-planner/src/test/unpruned_search.rs b/crates/akita-planner/src/test/unpruned_search.rs index 2d8b67cd4..2866d362c 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, @@ -44,7 +45,7 @@ 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 { + if level >= akita_schedules::ADAPTIVE_SEARCH_LEVELS { if *candidate_dimensions != suffix_dimensions { continue; } @@ -66,7 +67,7 @@ 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, @@ -98,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, @@ -140,7 +141,7 @@ fn enumerate_suffixes( }); } - let child_ceiling = if level + 1 >= MIXED_SEARCH_FOLD_LEVELS { + let child_ceiling = if level + 1 >= akita_schedules::ADAPTIVE_SEARCH_LEVELS { CommitmentRingDims::uniform(MIXED_SEARCH_SUFFIX_RING_DIMENSION) } else { params.role_dims() @@ -218,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(|| { diff --git a/crates/akita-schedules/src/candidate.rs b/crates/akita-schedules/src/candidate.rs index a2e63b43a..3670bb310 100644 --- a/crates/akita-schedules/src/candidate.rs +++ b/crates/akita-schedules/src/candidate.rs @@ -50,7 +50,7 @@ impl RingDimensionCandidate<'_> { native_width: usize, log_basis: u32, ) -> Option<(SisTableKey, usize)> { - let carrier_dimension = self.inner(); + let source_dimension = self.inner(); match self { Self::Fixed(dimensions) => { let role_dimension = match role { @@ -61,7 +61,7 @@ impl RingDimensionCandidate<'_> { projected_collision_role_price( policy, role, - carrier_dimension, + source_dimension, role_dimension, native_width, log_basis, @@ -80,13 +80,13 @@ impl RingDimensionCandidate<'_> { }; let mut best = None; for &role_dimension in dimensions { - if role_dimension > carrier_dimension || role_dimension > role_ceiling { + if role_dimension > source_dimension || role_dimension > role_ceiling { continue; } let Some((key, width)) = projected_collision_role_price( policy, role, - carrier_dimension, + source_dimension, role_dimension, native_width, log_basis, @@ -131,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; } @@ -149,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/generated/fp128_dense.rs b/crates/akita-schedules/src/generated/fp128_dense.rs index a8c98f174..dd2ebe427 100644 --- a/crates/akita-schedules/src/generated/fp128_dense.rs +++ b/crates/akita-schedules/src/generated/fp128_dense.rs @@ -53,27 +53,27 @@ pub(crate) static FP128_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 5700, positions_per_block: 256, live_blocks: 23 }, 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: 6653, 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: 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 }, ], 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(17, 4), 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: 256, 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: 13999, positions_per_block: 512, live_blocks: 28 }, 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: 18607, 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::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: 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 }, ], 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 }, }, @@ -122,9 +122,9 @@ pub(crate) static FP128_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 704794, positions_per_block: 2048, live_blocks: 345 }, 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: 211743, 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: 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 }, @@ -158,11 +158,11 @@ pub(crate) static FP128_DENSE_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 112722288, positions_per_block: 65536, live_blocks: 1721 }, 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: 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: 2199882, positions_per_block: 16384, live_blocks: 135 }, 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: 101063, 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: 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 }, ], @@ -202,7 +202,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated family_name: "fp128_dense", protocol_epoch: 3, cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinAdaptiveARankDimensionThenSetupAndProof, + selection_policy: SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, setup_field_budget: None, min_offloaded_witness_contraction: 3, sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, @@ -221,5 +221,5 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 3458533356553718245, key_count: 10, - key_digest: 10902553869371788854, + key_digest: 16961820471072486774, }; diff --git a/crates/akita-schedules/src/generated/fp128_onehot.rs b/crates/akita-schedules/src/generated/fp128_onehot.rs index e7c56ceb8..33eecce04 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot.rs @@ -29,74 +29,70 @@ pub(crate) static FP128_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: 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: 1698, positions_per_block: 256, live_blocks: 7 }, 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::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 }, + 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: 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 }, + 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: 128, positions_per_block: 16, 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 } } }, + 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: 916, positions_per_block: 128, 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: 2989, 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: 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: 1992, 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 { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(15, 4), num_digits_inner: 1, num_digits_fold: 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: 64, log_basis: 3, slice_count: 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 } } }, 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: 1012, positions_per_block: 128, 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: 2989, 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: 2499, 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: 1992, 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: 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: 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: 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: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 948, positions_per_block: 128, 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: 2989, 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: 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: 1992, 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 { 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: 64, 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: 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(15, 2), num_live_ring_elements_per_claim: 128, num_positions_per_block: 16, num_live_blocks: 8, log_basis_inner: 3, num_digits_inner: 43, 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, 1, 688, 65535, 256), 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, 2752, 7, 64) }, num_digits_fold: 3, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 16, 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 } } }, ], 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: 20989, 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::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22569, 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 }, ], @@ -105,28 +101,28 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ GeneratedFoldScheduleEntry { root: GeneratedRootFold { final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(16, 2), num_digits_inner: 1, num_digits_fold: 2, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 64, 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 } } }, + 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 } } }, 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: 1012, positions_per_block: 128, 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: 2989, 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: 2499, 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: 1992, 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: 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(18, 1), num_digits_inner: 1, num_digits_fold: 1, - commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2048, positions_per_block: 1024, 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 } } }, + 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: 1502, positions_per_block: 256, live_blocks: 6 }, 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::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 }, @@ -151,15 +147,14 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 2), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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, 1376, 7, 64) }, num_digits_fold: 2, 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 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 2), num_live_ring_elements_per_claim: 128, num_positions_per_block: 64, 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, 64, 16383, 128), 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: 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: 64, log_basis: 3, slice_count: 1 } } }, ], 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: 8854, positions_per_block: 1024, live_blocks: 9 }, 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: 5400, 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: 7176, 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 }, @@ -173,9 +168,8 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2596, positions_per_block: 256, live_blocks: 11 }, 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: 3, 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::Raw, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7639, 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::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 }, @@ -185,15 +179,15 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, ], 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: 10634, positions_per_block: 1024, live_blocks: 11 }, 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: 5784, 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: 9526, positions_per_block: 1024, live_blocks: 10 }, 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: 5592, 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::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 }, @@ -216,20 +210,20 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 4), num_digits_inner: 1, num_digits_fold: 3, - 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 } } }, + 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, ], 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: 20028, 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 }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 15689, 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 }, }, @@ -238,16 +232,16 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 4), num_digits_inner: 1, num_digits_fold: 3, 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 128, num_positions_per_block: 8, num_live_blocks: 16, 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, 1, 8, 16383, 128), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, ], 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: 23203, 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::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 19879, 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 }, ], @@ -262,9 +256,9 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 27588, positions_per_block: 512, live_blocks: 54 }, 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::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 20632, 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::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 }, ], @@ -297,12 +291,12 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 142532, positions_per_block: 512, live_blocks: 279 }, 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: 104951, 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 }, + 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 }, ], 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 }, }, @@ -315,12 +309,12 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 142532, positions_per_block: 512, live_blocks: 279 }, 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: 104951, 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 }, + 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 }, ], 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 }, }, @@ -329,14 +323,14 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 1), num_live_ring_elements_per_claim: 256, num_positions_per_block: 32, 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, 1, 32, 8191, 256), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 1), num_live_ring_elements_per_claim: 256, num_positions_per_block: 32, 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, 1, 32, 8191, 256), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 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, 1, 128, 1023, 256), 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, 344, 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: 256, 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: 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, 1, 128, 1023, 256), 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, 344, 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: 256, 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::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 798367, positions_per_block: 8192, live_blocks: 98 }, 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: 794751, positions_per_block: 8192, live_blocks: 98 }, 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: 58749, positions_per_block: 2048, live_blocks: 29 }, 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: 16371, 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 }, @@ -372,10 +366,10 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 549146, positions_per_block: 2048, live_blocks: 269 }, 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: 172527, positions_per_block: 4096, live_blocks: 43 }, 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: 21144, 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::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 }, ], @@ -390,13 +384,12 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 2629957, positions_per_block: 4096, live_blocks: 643 }, 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: 398279, positions_per_block: 4096, live_blocks: 98 }, 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: 42365, 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 }, + 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 }, }, @@ -428,11 +421,11 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ witness_partition: GeneratedWitnessPartition::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 100925765, positions_per_block: 65536, live_blocks: 1541 }, 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: 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: 2107002, positions_per_block: 16384, live_blocks: 129 }, 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: 99515, positions_per_block: 2048, live_blocks: 49 }, 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: 21531, 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: 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 }, ], @@ -453,7 +446,7 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated family_name: "fp128_onehot", protocol_epoch: 3, cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinAdaptiveARankDimensionThenSetupAndProof, + selection_policy: SelectionPolicyId::MinSetupMatrixFieldElementsThenProofPayload, setup_field_budget: None, min_offloaded_witness_contraction: 3, sis_modulus_profile: SisModulusProfileId::Q128OffsetA7F7, @@ -472,5 +465,5 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 3458533356553718245, key_count: 25, - key_digest: 9179620393641471586, + key_digest: 14629460886664035938, }; diff --git a/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs index f0a71c3e8..3bdc4c532 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs @@ -6,11 +6,11 @@ use super::{ #[rustfmt::skip] pub(crate) static FP128_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), 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: 64, log_basis: 3, slice_count: 1 } }, num_digits_inner: 1, inner_output_rank: 1, 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: 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 } }, 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: 16, 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 } }, 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, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 32, 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 } }, 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: 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 } }, 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, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 64, 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 } }, 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(14, 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 } }, 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(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: 64, 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: 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 } }, 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, 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: 64, 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: 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 } }, 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: 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(20, 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 } }, 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/walk.rs b/crates/akita-schedules/src/generated/walk.rs index 04cce099e..025f23f88 100644 --- a/crates/akita-schedules/src/generated/walk.rs +++ b/crates/akita-schedules/src/generated/walk.rs @@ -103,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)]; @@ -122,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/lib.rs b/crates/akita-schedules/src/lib.rs index 06e4860bf..92889bdb4 100644 --- a/crates/akita-schedules/src/lib.rs +++ b/crates/akita-schedules/src/lib.rs @@ -25,7 +25,7 @@ pub use resolve::{ }; pub use runtime::{ default_sis_security_policy, PlannerCostModelId, PlannerPolicy, RingDimensionScheduleMode, - RuntimeSchedulePolicy, SelectionPolicyId, + RuntimeSchedulePolicy, SelectionPolicyId, ADAPTIVE_SEARCH_LEVELS, }; /// Shared schedule-construction primitives used by offline search and generated-row replay. @@ -37,6 +37,6 @@ pub mod planner_support { 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 70ef74f9c..4ba9b9eef 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, @@ -38,8 +38,8 @@ impl PlannerCostModelId { pub enum SelectionPolicyId { /// Pick proof bytes, then physical setup fields, then canonical descriptor. MinEstimatedProofPayload, - /// Pick per-level A rank/dimension, then setup fields and proof payload. - MinAdaptiveARankDimensionThenSetupAndProof, + /// Pick physical setup fields, then proof bytes, then canonical descriptor. + MinSetupMatrixFieldElementsThenProofPayload, /// Pick first direct setup, proof bytes, total setup, then descriptor. MinFirstDirectSetupThenPayload, } @@ -56,7 +56,7 @@ impl SelectionPolicyId { ring_dimension_schedule_mode, RingDimensionScheduleMode::AdaptiveDimension { .. } ) { - Self::MinAdaptiveARankDimensionThenSetupAndProof + Self::MinSetupMatrixFieldElementsThenProofPayload } else { Self::MinEstimatedProofPayload } @@ -67,7 +67,7 @@ impl SelectionPolicyId { match self { Self::MinEstimatedProofPayload => 1, Self::MinFirstDirectSetupThenPayload => 2, - Self::MinAdaptiveARankDimensionThenSetupAndProof => 4, + Self::MinSetupMatrixFieldElementsThenProofPayload => 3, } } @@ -75,8 +75,8 @@ impl SelectionPolicyId { pub const fn name(self) -> &'static str { match self { Self::MinEstimatedProofPayload => "MinEstimatedProofPayload", - Self::MinAdaptiveARankDimensionThenSetupAndProof => { - "MinAdaptiveARankDimensionThenSetupAndProof" + Self::MinSetupMatrixFieldElementsThenProofPayload => { + "MinSetupMatrixFieldElementsThenProofPayload" } Self::MinFirstDirectSetupThenPayload => "MinFirstDirectSetupThenPayload", } @@ -98,6 +98,9 @@ pub enum RingDimensionScheduleMode { }, } +/// 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 { @@ -245,12 +248,18 @@ 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()?; + 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, @@ -266,18 +275,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( @@ -297,13 +298,15 @@ pub fn validate_policy(policy: &PlannerPolicy) -> Result<(), AkitaError> { fn validate_ring_dimension_schedule_mode(policy: &PlannerPolicy) -> Result<(), AkitaError> { match policy.ring_dimension_schedule_mode { RingDimensionScheduleMode::UniformDimension { ring_dimension } => { - validate_dimension(policy.uniform_ring_dimension, "uniform", 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, @@ -312,30 +315,27 @@ fn validate_ring_dimension_schedule_mode(policy: &PlannerPolicy) -> Result<(), A potential_b_dimensions, potential_d_dimensions, } => { - if num_search_levels == 0 || num_search_levels > MAX_RECURSION_DEPTH { + if num_search_levels != ADAPTIVE_SEARCH_LEVELS { return Err(AkitaError::InvalidSetup(format!( - "adaptive search levels must be in 1..={MAX_RECURSION_DEPTH}" + "adaptive search currently requires exactly {ADAPTIVE_SEARCH_LEVELS} levels, got {num_search_levels}" ))); } - validate_dimension( - policy.uniform_ring_dimension, - "uniform suffix", - uniform_suffix_dimension, - )?; for (role, dimensions) in [ - ("A", potential_a_dimensions), - ("B", potential_b_dimensions), - ("D", potential_d_dimensions), + (RingRole::Inner, potential_a_dimensions), + (RingRole::Outer, potential_b_dimensions), + (RingRole::Opening, potential_d_dimensions), ] { - validate_dimension_list(policy.uniform_ring_dimension, role, dimensions)?; + validate_dimension_list(policy, role, dimensions)?; if !dimensions.contains(&uniform_suffix_dimension) { return Err(AkitaError::InvalidSetup(format!( - "adaptive {role} domain must contain suffix D{uniform_suffix_dimension}" + "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 {role} dimensions must be at least suffix D{uniform_suffix_dimension}" + "adaptive {} dimensions must be at least suffix D{uniform_suffix_dimension}", + role_name(role) ))); } } @@ -344,35 +344,77 @@ fn validate_ring_dimension_schedule_mode(policy: &PlannerPolicy) -> Result<(), A Ok(()) } -fn validate_dimension( - setup_dimension: usize, - label: &str, +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> { - if dimension == 0 || !dimension.is_power_of_two() || !setup_dimension.is_multiple_of(dimension) - { + 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!( - "{label} D{dimension} must be a nonzero power of two dividing setup D{setup_dimension}" + "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" ))); } Ok(()) } fn validate_dimension_list( - setup_dimension: usize, - role: &str, + policy: &PlannerPolicy, + role: RingRole, dimensions: &[usize], ) -> Result<(), AkitaError> { if dimensions.is_empty() { return Err(AkitaError::InvalidSetup(format!( - "adaptive {role} domain must be nonempty" + "adaptive {} domain must be nonempty", + role_name(role) ))); } for (index, &dimension) in dimensions.iter().enumerate() { - validate_dimension(setup_dimension, role, dimension)?; + validate_scheduled_dimension(policy, role, dimension)?; if index > 0 && dimensions[index - 1] >= dimension { return Err(AkitaError::InvalidSetup(format!( - "adaptive {role} domain must be strictly sorted and duplicate-free" + "adaptive {} domain must be strictly sorted and duplicate-free", + role_name(role) ))); } } @@ -574,7 +616,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( @@ -583,10 +634,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-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 96d2b5738..cc81cbdbc 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/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/mixed-ring-dimension-per-level.md b/specs/mixed-ring-dimension-per-level.md index 08136727b..c62f2488c 100644 --- a/specs/mixed-ring-dimension-per-level.md +++ b/specs/mixed-ring-dimension-per-level.md @@ -241,7 +241,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,13 +260,12 @@ 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_onehot_schedule` helper compares the separately -generated uniform-D64 and default per-level catalogs by proof bytes, then uses -the smaller setup-generation dimension as a tie-break. It is a family selector -outside the schedule DP and does not run a new search. +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 @@ -424,8 +424,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`. @@ -724,11 +725,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 +759,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. @@ -801,13 +803,11 @@ byte-identical. The current branch implements the first offline direct scalar cut while preserving all generated catalogs: -- `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 @@ -828,7 +828,8 @@ preserving all generated catalogs: to use the existing grouped 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 @@ -907,7 +908,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 +923,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 | @@ -1629,8 +1630,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/profile-bench-coverage-matrix.md b/specs/profile-bench-coverage-matrix.md index b3ebc1557..96de6f3d2 100644 --- a/specs/profile-bench-coverage-matrix.md +++ b/specs/profile-bench-coverage-matrix.md @@ -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_onehot_schedule` selector, 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` to compare supported one-hot families. +- **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 From daff3a1e028a9cee75cd9c0a0e2ca60b83973935 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Fri, 7 Aug 2026 10:07:10 -0700 Subject: [PATCH 16/24] fix(tests): honor adaptive root dimensions --- crates/akita-pcs/tests/akita_e2e.rs | 46 +++++++++---------- .../akita-pcs/tests/batched_aggregated_e2e.rs | 8 ++-- crates/akita-pcs/tests/setup.rs | 43 ++++++++--------- crates/akita-pcs/tests/single_poly_e2e.rs | 6 +-- 4 files changed, 53 insertions(+), 50 deletions(-) diff --git a/crates/akita-pcs/tests/akita_e2e.rs b/crates/akita-pcs/tests/akita_e2e.rs index ab435830b..8daf52e69 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; @@ -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 = common::opening_from_poly::(&poly, &pt, &layout); let setup = AkitaCommitmentScheme::::setup_prover(NV, 1).unwrap(); let prepared = CpuBackend.prepare_setup(&setup).unwrap(); @@ -437,18 +437,18 @@ fn adaptive_dense_prove_verify() { let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { type Cfg = fp128::Dense; - const D: usize = Cfg::D; 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); @@ -624,13 +624,13 @@ fn trace_internalization_rejects_tampered_recursive_fold_handle() { let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { type Cfg = fp128::OneHot; - const D: usize = Cfg::D; 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")] @@ -831,12 +831,12 @@ fn adaptive_onehot_direct_tail_uses_terminal_schedule_basis() { let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { type Cfg = fp128::OneHot; - const D: usize = Cfg::D; 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); @@ -932,12 +932,12 @@ fn batched_onehot_same_point_round_trip() { // NV=20 is large enough to include a recursive suffix in the generated // adaptive two-claim schedule. type Cfg = fp128::OneHot; - const D: usize = Cfg::D; 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), )) @@ -956,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); @@ -969,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,13 +1071,13 @@ fn batched_onehot_same_point_rejects_tampered_root_stage1_range_image_evaluation let _guard = E2E_TEST_LOCK.lock().unwrap(); run_on_large_stack(|| { type Cfg = fp128::OneHot; - const D: usize = Cfg::D; 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); @@ -1088,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 e6b6c4595..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") } diff --git a/crates/akita-pcs/tests/setup.rs b/crates/akita-pcs/tests/setup.rs index 5684c6c03..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(); diff --git a/crates/akita-pcs/tests/single_poly_e2e.rs b/crates/akita-pcs/tests/single_poly_e2e.rs index 077aad53d..376daaaee 100644 --- a/crates/akita-pcs/tests/single_poly_e2e.rs +++ b/crates/akita-pcs/tests/single_poly_e2e.rs @@ -121,7 +121,6 @@ fn run_single_onehot(nv: usize) { // --------------------------------------------------------------------------- type DenseCfg = fp128::Dense; -const DENSE_D: usize = DenseCfg::D; fn run_single_dense(nv: usize) { init_rayon_pool(); @@ -130,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(); From 95dfaf449c0676cbb226f8db1c704df3d1878d83 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 7 Aug 2026 14:14:54 -0400 Subject: [PATCH 17/24] docs(spec): align mixed-D setup model Remove the obsolete setup generation dimension from live requirements. Document the current local B/D rank choice as a P0 limitation and keep full Cartesian optimization as the target. --- specs/mixed-ring-dimension-per-level.md | 176 ++++++++++++++---------- 1 file changed, 103 insertions(+), 73 deletions(-) diff --git a/specs/mixed-ring-dimension-per-level.md b/specs/mixed-ring-dimension-per-level.md index c62f2488c..caca5a072 100644 --- a/specs/mixed-ring-dimension-per-level.md +++ b/specs/mixed-ring-dimension-per-level.md @@ -49,13 +49,16 @@ dimension needed by this experiment: 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. +this geometry. For the default direct scalar fp128 one-hot and dense families, +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 is deferred. Runtime code replays +the generated catalogs and does not invoke the planner. Recursive setup +offload, direct multi-chunk search, and heterogeneous mixed-D multi-group roots +also remain deferred. Grouped paths preserve committed profiles and use the +uniform D64 suffix policy rather than planner-native mixed-D search. The +benchmark profiles in this document remain synthetic schedules built in +`akita-pcs` test support unless a section says otherwise. The implemented direct-scalar policy is: @@ -65,12 +68,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 +160,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 +194,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: @@ -332,29 +347,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 +378,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 @@ -659,10 +679,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 @@ -780,13 +797,13 @@ 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 @@ -809,14 +826,15 @@ preserving all generated catalogs: 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; @@ -858,22 +876,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 @@ -884,15 +901,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. @@ -942,7 +962,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 @@ -951,9 +971,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. @@ -1246,11 +1267,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 @@ -1460,9 +1481,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. @@ -1613,10 +1634,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 From 8e243cb7538befbd7e92bf3871b3aded6e78e326 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 7 Aug 2026 14:29:43 -0400 Subject: [PATCH 18/24] fix(benches): restore adaptive catalog replay --- crates/akita-pcs/benches/akita_e2e.rs | 12 +++++------ crates/akita-pcs/benches/root_kernels.rs | 12 +++++------ .../akita-planner/src/generated_families.rs | 1 + .../src/generated/fp128_onehot.rs | 20 +++++++++++++++++-- 4 files changed, 31 insertions(+), 14 deletions(-) diff --git a/crates/akita-pcs/benches/akita_e2e.rs b/crates/akita-pcs/benches/akita_e2e.rs index 8f28a2066..3cdf34656 100644 --- a/crates/akita-pcs/benches/akita_e2e.rs +++ b/crates/akita-pcs/benches/akita_e2e.rs @@ -419,23 +419,23 @@ fn bench_onehot_phases(c, "dense-d64", 14); + bench_dense_phases::<{ fp128::Dense::D }, fp128::Dense>(c, "dense-adaptive", 14); } fn bench_dense_nv16(c: &mut Criterion) { - bench_dense_phases::<{ fp128::D64Dense::D }, fp128::D64Dense>(c, "dense-d64", 16); + bench_dense_phases::<{ fp128::Dense::D }, fp128::Dense>(c, "dense-adaptive", 16); } fn bench_dense_nv24(c: &mut Criterion) { - bench_dense_phases::<{ fp128::D64Dense::D }, fp128::D64Dense>(c, "dense-d64", 24); + 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::<{ fp128::OneHot::D }, fp128::OneHot>(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::<{ fp128::OneHot::D }, fp128::OneHot>(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::<{ fp128::OneHot::D }, fp128::OneHot>(c, "onehot-adaptive", 25); } criterion_group!( diff --git a/crates/akita-pcs/benches/root_kernels.rs b/crates/akita-pcs/benches/root_kernels.rs index 4266bc49d..a249140f9 100644 --- a/crates/akita-pcs/benches/root_kernels.rs +++ b/crates/akita-pcs/benches/root_kernels.rs @@ -17,7 +17,7 @@ use rand::{Rng, SeedableRng}; type F = fp128::Field; 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-planner/src/generated_families.rs b/crates/akita-planner/src/generated_families.rs index a888446c4..634a85787 100644 --- a/crates/akita-planner/src/generated_families.rs +++ b/crates/akita-planner/src/generated_families.rs @@ -81,6 +81,7 @@ const FP128_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(20), PolynomialGroupLayout::new(20, 2), PolynomialGroupLayout::new(20, 4), + PolynomialGroupLayout::singleton(25), PolynomialGroupLayout::singleton(28), PolynomialGroupLayout::singleton(30), PolynomialGroupLayout::new(30, 4), diff --git a/crates/akita-schedules/src/generated/fp128_onehot.rs b/crates/akita-schedules/src/generated/fp128_onehot.rs index 33eecce04..a45cd3419 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot.rs @@ -247,6 +247,22 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ ], 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(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: 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 }, + ], + 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: 1, num_digits_fold: 2, @@ -464,6 +480,6 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated 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: 3458533356553718245, - key_count: 25, - key_digest: 14629460886664035938, + key_count: 26, + key_digest: 8976661807121841406, }; From 4454d3a888e78512c557bf4ba0529e7bcbaca934 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Fri, 7 Aug 2026 12:11:08 -0700 Subject: [PATCH 19/24] feat(schedules): support adaptive multi-chunk rings (#373) * feat(schedules): support adaptive multi-chunk rings * feat(schedules): support adaptive recursive rings * fix(schedules): include adaptive recursive precommits * chore(schedules): regenerate after planner rebase * fix(planner): preserve fixed-D64 tie regression --- .github/workflows/ci.yml | 2 +- .github/workflows/profile-bench.yml | 15 +- book/src/usage/profiling.md | 10 +- crates/akita-config/Cargo.toml | 26 +- crates/akita-config/src/lib.rs | 7 +- .../akita-config/src/proof_optimized/fp128.rs | 51 ++-- .../akita-config/src/recursive_commitment.rs | 51 +++- crates/akita-config/tests/generated_tables.rs | 80 +++++-- crates/akita-pcs/Cargo.toml | 14 +- crates/akita-pcs/examples/profile/modes.rs | 94 ++++---- crates/akita-pcs/src/scheme/tests/onehot.rs | 11 +- crates/akita-pcs/tests/akita_e2e.rs | 8 +- crates/akita-pcs/tests/common/mod.rs | 13 +- .../tests/distributed_setup_offload_e2e.rs | 46 +++- crates/akita-pcs/tests/recursive_setup_e2e.rs | 4 +- .../examples/mixed_dimension_search.rs | 47 ++-- crates/akita-planner/src/emit/mod.rs | 3 + .../akita-planner/src/generated_families.rs | 124 +++++++--- crates/akita-planner/src/planner.rs | 90 ++++--- crates/akita-planner/src/schedule_params.rs | 48 ++++ .../schedule_params/candidate/recursive.rs | 1 + .../schedule_params/candidate/setup_prefix.rs | 13 +- .../src/schedule_params/suffix_dp.rs | 224 ++++++++++++------ .../akita-planner/src/test/schedule_params.rs | 180 +++++++++++++- crates/akita-schedules/Cargo.toml | 18 +- ...p128_d64_dense_multi_chunk_precommitted.rs | 15 -- ...fp128_d64_onehot_recursive_precommitted.rs | 1 + ...ti_chunk.rs => fp128_dense_multi_chunk.rs} | 33 +-- .../fp128_dense_multi_chunk_precommitted.rs | 10 + .../src/generated/fp128_onehot_multi_chunk.rs | 91 +++++++ .../fp128_onehot_multi_chunk_precommitted.rs | 11 + ...r2.rs => fp128_onehot_multi_chunk_w2r2.rs} | 57 +++-- ...8_onehot_multi_chunk_w2r2_precommitted.rs} | 14 +- ...r2.rs => fp128_onehot_multi_chunk_w4r2.rs} | 36 +-- ...28_onehot_multi_chunk_w4r2_precommitted.rs | 15 ++ .../src/generated/fp128_onehot_recursive.rs | 72 ++++++ ...fp128_onehot_recursive_multi_chunk_w8r2.rs | 73 ++++++ ...recursive_multi_chunk_w8r2_precommitted.rs | 11 + ...=> fp128_onehot_recursive_precommitted.rs} | 13 +- crates/akita-schedules/src/generated/mod.rs | 117 ++++++--- crates/akita-schedules/src/runtime.rs | 4 +- scripts/check_profile_ci_features.sh | 10 +- scripts/profile_bench_report.py | 20 +- scripts/tests/test_profile_bench_report.py | 4 +- specs/distributed-planner.md | 85 ++++--- specs/distributed-setup-offloading.md | 64 +++-- specs/mixed-ring-dimension-per-level.md | 195 ++++++++++----- specs/profile-bench-coverage-matrix.md | 10 +- 48 files changed, 1545 insertions(+), 596 deletions(-) delete mode 100644 crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk_precommitted.rs rename crates/akita-schedules/src/generated/{fp128_d64_dense_multi_chunk.rs => fp128_dense_multi_chunk.rs} (74%) create mode 100644 crates/akita-schedules/src/generated/fp128_dense_multi_chunk_precommitted.rs create mode 100644 crates/akita-schedules/src/generated/fp128_onehot_multi_chunk.rs create mode 100644 crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_precommitted.rs rename crates/akita-schedules/src/generated/{fp128_d64_onehot_multi_chunk_w2r2.rs => fp128_onehot_multi_chunk_w2r2.rs} (60%) rename crates/akita-schedules/src/generated/{fp128_d64_onehot_multi_chunk_w2r2_precommitted.rs => fp128_onehot_multi_chunk_w2r2_precommitted.rs} (52%) rename crates/akita-schedules/src/generated/{fp128_d64_onehot_multi_chunk_w4r2.rs => fp128_onehot_multi_chunk_w4r2.rs} (69%) create mode 100644 crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2_precommitted.rs create mode 100644 crates/akita-schedules/src/generated/fp128_onehot_recursive.rs create mode 100644 crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2.rs create mode 100644 crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2_precommitted.rs rename crates/akita-schedules/src/generated/{fp128_d64_onehot_multi_chunk_w4r2_precommitted.rs => fp128_onehot_recursive_precommitted.rs} (54%) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b9ad2fcb4..4fda2998e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -197,7 +197,7 @@ 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 diff --git a/.github/workflows/profile-bench.yml b/.github/workflows/profile-bench.yml index 8cedb80ec..a7621e827 100644 --- a/.github/workflows/profile-bench.yml +++ b/.github/workflows/profile-bench.yml @@ -24,9 +24,8 @@ 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: `onehot_fp128` is the canonical direct one-hot profile. Explicit - # D64 rows remain in the matrix as uniform and recursive/distributed - # comparison profiles. + # - 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 @@ -76,15 +75,15 @@ jobs: 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/profiling.md b/book/src/usage/profiling.md index ebaebb52b..9322e592e 100644 --- a/book/src/usage/profiling.md +++ b/book/src/usage/profiling.md @@ -79,11 +79,11 @@ Committed-fold A-role pricing (every cell folds securely): | `dense_fp128` | 24 | 1 | `direct` | | `onehot_fp128` | 32 | 1 | `direct` | | `onehot_fp128_multi_group` | 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` | +| `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/crates/akita-config/Cargo.toml b/crates/akita-config/Cargo.toml index 54c3c02ee..15a8ba786 100644 --- a/crates/akita-config/Cargo.toml +++ b/crates/akita-config/Cargo.toml @@ -32,10 +32,13 @@ all-schedules = [ "schedules-default", "schedules-fp128-d64-onehot-recursive", "schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2", + "schedules-fp128-onehot-recursive", + "schedules-fp128-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-multi-chunk", + "schedules-fp128-onehot-multi-chunk-w2r2", + "schedules-fp128-onehot-multi-chunk-w4r2", + "schedules-fp128-dense-multi-chunk", ] schedules-fp128-onehot = ["akita-schedules/fp128-onehot"] schedules-fp128-dense = ["akita-schedules/fp128-dense"] @@ -45,18 +48,23 @@ schedules-fp128-d64-onehot-recursive = [ schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2 = [ "akita-schedules/fp128-d64-onehot-recursive-multi-chunk-w8r2", ] +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-multi-chunk = [ "akita-schedules/fp128-d64-onehot-multi-chunk", ] -schedules-fp128-d64-onehot-multi-chunk-w2r2 = [ - "akita-schedules/fp128-d64-onehot-multi-chunk-w2r2", +schedules-fp128-onehot-multi-chunk = [ + "akita-schedules/fp128-onehot-multi-chunk", ] -schedules-fp128-d64-onehot-multi-chunk-w4r2 = [ - "akita-schedules/fp128-d64-onehot-multi-chunk-w4r2", +schedules-fp128-onehot-multi-chunk-w2r2 = [ + "akita-schedules/fp128-onehot-multi-chunk-w2r2", ] -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"] diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index 968c5bd76..9fbc25592 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -266,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 diff --git a/crates/akita-config/src/proof_optimized/fp128.rs b/crates/akita-config/src/proof_optimized/fp128.rs index ad60d1dec..176cc4bfb 100644 --- a/crates/akita-config/src/proof_optimized/fp128.rs +++ b/crates/akita-config/src/proof_optimized/fp128.rs @@ -57,22 +57,26 @@ impl OneHot { #[derive(Clone, Copy, Debug, Default)] pub struct D512OneHot; -/// Multi-chunk (distributed-prover) companion of [`D64OneHot`]. Shares every -/// layout parameter with its sibling but prices the chunked witness layout. +/// Uniform-D64 multi-chunk companion retained as the base of the recursive +/// distributed-prover preset. #[derive(Clone, Copy, Debug, Default)] pub struct D64OneHotMultiChunk; -/// Multi-chunk companion with `2` witness chunks and `2` leading fold levels. +/// Direct multi-chunk companion of [`OneHot`] using the W8R2 profile. #[derive(Clone, Copy, Debug, Default)] -pub struct D64OneHotMultiChunkW2R2; +pub struct OneHotMultiChunk; -/// Multi-chunk companion with `4` witness chunks and `2` leading fold levels. +/// Direct multi-chunk companion of [`OneHot`] using the W2R2 profile. #[derive(Clone, Copy, Debug, Default)] -pub struct D64OneHotMultiChunkW4R2; +pub struct OneHotMultiChunkW2R2; -/// Multi-chunk (distributed-prover) companion of [`D64Dense`]. +/// Direct multi-chunk companion of [`OneHot`] using the W4R2 profile. #[derive(Clone, Copy, Debug, Default)] -pub struct D64DenseMultiChunk; +pub struct OneHotMultiChunkW4R2; + +/// Direct multi-chunk companion of [`Dense`] using the W8R2 profile. +#[derive(Clone, Copy, Debug, Default)] +pub struct DenseMultiChunk; impl_proof_optimized_preset!( D64Dense, @@ -168,23 +172,30 @@ impl_multi_chunk_companion!( fp128_d64_onehot_multi_chunk_table ); impl_multi_chunk_companion!( - D64OneHotMultiChunkW2R2, - D64OneHot, + OneHotMultiChunk, + OneHot, + akita_types::MultiChunkProfileId::W8R2, + "schedules-fp128-onehot-multi-chunk", + fp128_onehot_multi_chunk_table +); +impl_multi_chunk_companion!( + 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 ); diff --git a/crates/akita-config/src/recursive_commitment.rs b/crates/akita-config/src/recursive_commitment.rs index 2aff2b37b..ff7c971b9 100644 --- a/crates/akita-config/src/recursive_commitment.rs +++ b/crates/akita-config/src/recursive_commitment.rs @@ -9,7 +9,9 @@ use akita_types::{ }; #[cfg(any( feature = "schedules-fp128-d64-onehot-recursive", - feature = "schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2" + 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; @@ -83,6 +85,20 @@ impl CommitmentConfig for RecursiveCommitmentConfig return Some(akita_schedules::fp128_d64_onehot_recursive_multi_chunk_w8r2_table()); } } + #[cfg(feature = "schedules-fp128-onehot-recursive")] + { + if TypeId::of::() == TypeId::of::() { + return Some(akita_schedules::fp128_onehot_recursive_table()); + } + } + #[cfg(feature = "schedules-fp128-onehot-recursive-multi-chunk-w8r2")] + { + if TypeId::of::() + == TypeId::of::() + { + return Some(akita_schedules::fp128_onehot_recursive_multi_chunk_w8r2_table()); + } + } None } @@ -107,6 +123,39 @@ impl CommitmentConfig for RecursiveCommitmentConfig } } +#[cfg(all( + test, + any( + feature = "schedules-fp128-onehot-recursive", + feature = "schedules-fp128-onehot-recursive-multi-chunk-w8r2" + ) +))] +mod adaptive_precommit_tests { + use super::*; + use crate::proof_optimized::fp128; + use crate::PrecommittedCommitmentConfig; + use akita_types::OpeningClaimsLayout; + + 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"); + } + + #[cfg(feature = "schedules-fp128-onehot-recursive")] + #[test] + fn onehot_recursive_catalog_exposes_base_precommit_profiles() { + assert_nv16_precommit::(); + } + + #[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-d64-onehot-recursive"))] mod tests { use super::*; diff --git a/crates/akita-config/tests/generated_tables.rs b/crates/akita-config/tests/generated_tables.rs index 9c796c39d..fdf81e0fe 100644 --- a/crates/akita-config/tests/generated_tables.rs +++ b/crates/akita-config/tests/generated_tables.rs @@ -80,14 +80,23 @@ fn family_catalog_is_linked(family: &GeneratedFamily) -> bool { as CommitmentConfig>::schedule_catalog() .is_some() } + "fp128_onehot_recursive" => { + as CommitmentConfig>::schedule_catalog() + .is_some() + } + "fp128_onehot_recursive_multi_chunk_w8r2" => { + as CommitmentConfig>::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(), @@ -322,18 +331,25 @@ fn family_catalog( "fp128_d64_onehot_recursive_multi_chunk_w8r2" => prepare_family_catalog::< akita_config::RecursiveCommitmentConfig, >(family, keys), + "fp128_onehot_recursive" => prepare_family_catalog::< + akita_config::RecursiveCommitmentConfig, + >(family, keys), + "fp128_onehot_recursive_multi_chunk_w8r2" => prepare_family_catalog::< + akita_config::RecursiveCommitmentConfig, + >(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), @@ -379,20 +395,29 @@ fn assert_family_group_batch_table_hit(family: &GeneratedFamily, requests: &[Gro "fp128_d64_onehot_recursive_multi_chunk_w8r2" => assert_group_batch_table_hits::< akita_config::RecursiveCommitmentConfig, >(family.module_name, requests), + "fp128_onehot_recursive" => assert_group_batch_table_hits::< + akita_config::RecursiveCommitmentConfig, + >(family.module_name, requests), + "fp128_onehot_recursive_multi_chunk_w8r2" => assert_group_batch_table_hits::< + akita_config::RecursiveCommitmentConfig, + >(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" => { + assert_group_batch_table_hits::(family.module_name, requests) + } + "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) @@ -460,17 +485,26 @@ fn resolve_family_group_batch_schedule( "fp128_d64_onehot_recursive_multi_chunk_w8r2" => table_backed_group_batch_schedule::< akita_config::RecursiveCommitmentConfig, >(request), + "fp128_onehot_recursive" => table_backed_group_batch_schedule::< + akita_config::RecursiveCommitmentConfig, + >(request), + "fp128_onehot_recursive_multi_chunk_w8r2" => table_backed_group_batch_schedule::< + akita_config::RecursiveCommitmentConfig, + >(request), "fp128_d64_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" => { + 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-pcs/Cargo.toml b/crates/akita-pcs/Cargo.toml index d853d9fde..61ea70632 100644 --- a/crates/akita-pcs/Cargo.toml +++ b/crates/akita-pcs/Cargo.toml @@ -49,20 +49,20 @@ profile-ci = [ "akita-config/schedules-fp128-onehot", "akita-config/schedules-fp32-d128-onehot", "akita-config/schedules-fp64-d128-onehot", - "akita-config/schedules-fp128-onehot", - "akita-config/schedules-fp128-d64-onehot-recursive", - "akita-config/schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2", + "akita-config/schedules-fp128-onehot-recursive", + "akita-config/schedules-fp128-onehot-recursive-multi-chunk-w8r2", "akita-config/schedules-fp128-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-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 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 = ["akita-config/schedules-fp128-onehot"] -schedules-fp128-d64-dense-multi-chunk = [ - "akita-config/schedules-fp128-d64-dense-multi-chunk", +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/examples/profile/modes.rs b/crates/akita-pcs/examples/profile/modes.rs index 565cf0e2f..122c23d09 100644 --- a/crates/akita-pcs/examples/profile/modes.rs +++ b/crates/akita-pcs/examples/profile/modes.rs @@ -188,24 +188,24 @@ const PROFILE_CI_MODES: &[ProfileMode] = &[ 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", @@ -232,24 +232,24 @@ const PROFILE_ALL_MODES: &[ProfileMode] = &[ 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: "dense_fp32_d64", @@ -297,11 +297,11 @@ fn profile_modes() -> &'static [ProfileMode] { #[cfg(not(feature = "profile-onehot-fp128"))] const EXCLUDED_FROM_ALL_SWEEP: &[&str] = &[ "onehot_fp128_multi_group", - "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_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). @@ -429,33 +429,27 @@ fn run_profile_onehot_fp128_multi_group(nv: usize, num_polys: usize) { ); } -fn run_profile_onehot_fp128_d64_multi_group_recursive(nv: usize, num_polys: usize) { - type Cfg = fp128::D64OneHot; +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_d64_multi_group_recursive", - "recursive setup", + "onehot_fp128_multi_group_recursive", + "adaptive ring dimensions + recursive setup", 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; +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_d64_multi_group_recursive_multi_chunk_w8r2", - "recursive setup offloading + W8R2 chunked witness: num_chunks=8 x 2 leading levels", + "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, >( @@ -467,34 +461,34 @@ 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, diff --git a/crates/akita-pcs/src/scheme/tests/onehot.rs b/crates/akita-pcs/src/scheme/tests/onehot.rs index cfd56449c..0b8701bd0 100644 --- a/crates/akita-pcs/src/scheme/tests/onehot.rs +++ b/crates/akita-pcs/src/scheme/tests/onehot.rs @@ -657,10 +657,13 @@ fn multi_group_root_allows_final_a_smaller_than_precommitted_a() { #[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 8daf52e69..ce32b13a1 100644 --- a/crates/akita-pcs/tests/akita_e2e.rs +++ b/crates/akita-pcs/tests/akita_e2e.rs @@ -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 = common::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,7 +427,7 @@ 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"); }); } diff --git a/crates/akita-pcs/tests/common/mod.rs b/crates/akita-pcs/tests/common/mod.rs index 167ffae5d..bc6b3eadb 100644 --- a/crates/akita-pcs/tests/common/mod.rs +++ b/crates/akita-pcs/tests/common/mod.rs @@ -525,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 @@ -645,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/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-planner/examples/mixed_dimension_search.rs b/crates/akita-planner/examples/mixed_dimension_search.rs index 6804692a7..a651464fd 100644 --- a/crates/akita-planner/examples/mixed_dimension_search.rs +++ b/crates/akita-planner/examples/mixed_dimension_search.rs @@ -1,7 +1,5 @@ use akita_config::{ - policy_of, - proof_optimized::fp128::{D64OneHot, OneHot}, - CommitmentConfig, RecursiveCommitmentConfig, + policy_of, proof_optimized::fp128::OneHot, CommitmentConfig, RecursiveCommitmentConfig, }; use akita_planner::find_schedule; use akita_types::{AkitaScheduleLookupKey, CommittedGroupProfile, PolynomialGroupLayout}; @@ -92,28 +90,28 @@ fn main() -> Result<(), akita_field::AkitaError> { &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_policy = policy_of::(); let precommit = find_schedule( &precommit_key, - D64OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &[], &precommit_policy, - D64OneHot::ring_challenge_config, + OneHot::ring_challenge_config, )?; let descriptor = CommittedGroupProfile::from_params( precommit_layout, @@ -124,25 +122,20 @@ fn main() -> Result<(), akita_field::AkitaError> { 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 8ba0502f9..fa1c5bbf4 100644 --- a/crates/akita-planner/src/emit/mod.rs +++ b/crates/akita-planner/src/emit/mod.rs @@ -767,6 +767,9 @@ pub fn emit_precommitted_profiles_module(spec: &EmitSpec) -> Result( if std::any::TypeId::of::() == std::any::TypeId::of::() || std::any::TypeId::of::() == std::any::TypeId::of::() || 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::() + || 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(15, 2))?, @@ -419,19 +428,33 @@ 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::()?; + 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::() { - let mut keys = recursive_d64_onehot_profile_keys::()?; + 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::(); + return recursive_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()) } @@ -447,17 +470,27 @@ fn recursive_profile_group_batch_keys_for_recursive_cfg() == std::any::TypeId::of::>() { - return recursive_d64_onehot_profile_keys::(); + return recursive_onehot_profile_keys::(); } if 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::>() + { + return recursive_onehot_profile_keys::(); + } + if std::any::TypeId::of::() + == std::any::TypeId::of::>() + { + 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)?; @@ -628,7 +661,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>, } }; @@ -738,9 +775,8 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ RecursiveCommitmentConfig, fp128::D64OneHot ), - // 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. + // Fixed-D64 comparison catalog for recursive setup offloading combined with + // the 8-chunk witness layout. family_row!( recursive, "fp128_d64_onehot_recursive_multi_chunk_w8r2", @@ -750,6 +786,24 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ RecursiveCommitmentConfig, fp128::D64OneHotMultiChunk ), + family_row!( + recursive, + "fp128_onehot_recursive", + "FP128_ONEHOT_RECURSIVE_SCHEDULES", + "fp128-onehot-recursive", + &[], + RecursiveCommitmentConfig, + fp128::OneHot + ), + family_row!( + recursive, + "fp128_onehot_recursive_multi_chunk_w8r2", + "FP128_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES", + "fp128-onehot-recursive-multi-chunk-w8r2", + &[], + RecursiveCommitmentConfig, + fp128::OneHotMultiChunk + ), GeneratedFamily { module_name: "fp128_dense", const_name: "FP128_DENSE_SCHEDULES", @@ -765,9 +819,9 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ precommitted_profiles: precommitted_profiles::, explicit_precommitted_group: explicit_precommitted_group::, }, - // 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. + // The D64 W8R2 family remains as an explicit fixed-dimension comparison. + // Production direct and recursive multi-chunk families inherit adaptive + // dimension selection from `OneHot` / `Dense`. family_row!( group_batch, "fp128_d64_onehot_multi_chunk", @@ -778,26 +832,34 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ ), 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", + "FP128_ONEHOT_MULTI_CHUNK_SCHEDULES", + "fp128-onehot-multi-chunk", + FP128_ONEHOT_MULTI_CHUNK_KEYS, + fp128::OneHotMultiChunk + ), + family_row!( + group_batch, + "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/planner.rs b/crates/akita-planner/src/planner.rs index baf59e818..39c2041d4 100644 --- a/crates/akita-planner/src/planner.rs +++ b/crates/akita-planner/src/planner.rs @@ -9,9 +9,9 @@ use akita_types::sis::{ InnerCommitMatrixParams, OpenCommitMatrixParams, OuterCommitMatrixParams, }; use akita_types::{ - AkitaScheduleLookupKey, CommittedGroupParams, CommittedGroupProfile, DecompositionParams, - OpeningClaimsLayout, PlannedFoldSchedule, PolynomialGroupLayout, PrecommittedLevelParams, - WitnessLayout, + AkitaScheduleLookupKey, CommitmentRingDims, CommittedGroupParams, CommittedGroupProfile, + DecompositionParams, OpeningClaimsLayout, PlannedFoldSchedule, PolynomialGroupLayout, + PrecommittedLevelParams, WitnessLayout, }; use akita_schedules::planner_support::{sis_key_at_dimension, RingDimensionCandidate}; @@ -294,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.inner(), + shared_opening_ring_dimension, candidate_log_basis, )?; for block_index_bits in (min_block_index_bits..=max_block_index_bits).rev() { @@ -456,17 +469,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)) = dimensions.collision_role_price( + let Some((open_key, main_d_width)) = dimensions.collision_role_price( policy, akita_types::SisMatrixRole::Open, - 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); @@ -509,7 +525,7 @@ fn validate_adaptive_dimension_schedule_request( } 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.selection_policy @@ -519,11 +535,6 @@ fn validate_adaptive_dimension_schedule_request( "adaptive search requires MinSetupMatrixFieldElementsThenProofPayload".into(), )); } - if policy.witness_chunk.uses_multi_chunk() { - return Err(AkitaError::InvalidSetup( - "mixed-D search does not yet support direct multi-chunk planning".into(), - )); - } Ok(()) } @@ -551,30 +562,32 @@ pub fn find_schedule( ); } - // Adaptive search currently optimizes scalar roots. Grouped roots keep - // every already-committed A/B profile exact and plan the combined - // opening at the policy's uniform suffix dimension. - 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, + if !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"); }; - 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 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; @@ -624,6 +637,7 @@ pub fn find_schedule( current_witness_len: root_input_witness_len, current_lb: 0, incoming_setup_prefix: None, + dimension_ceiling: CommitmentRingDims::uniform(active_policy.uniform_ring_dimension), payload_phase: akita_types::CommitmentPayloadPhase::CompressedPrefix, }, 0, diff --git a/crates/akita-planner/src/schedule_params.rs b/crates/akita-planner/src/schedule_params.rs index 1ea845ef6..b0901ecab 100644 --- a/crates/akita-planner/src/schedule_params.rs +++ b/crates/akita-planner/src/schedule_params.rs @@ -46,6 +46,54 @@ pub(crate) use setup_score::{ }; pub(crate) use suffix_dp::{derive_optimal_suffix_schedule, ScheduleMemo, SuffixCtx, SuffixState}; +fn exact_dimension_candidates( + policy: &PlannerPolicy, + level: usize, + ceiling: CommitmentRingDims, +) -> Result, AkitaError> { + ceiling.validate_role_projection()?; + let candidates = match policy.ring_dimension_schedule_mode { + crate::RingDimensionScheduleMode::UniformDimension { ring_dimension } => { + vec![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![CommitmentRingDims::uniform(uniform_suffix_dimension)] + } 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(CommitmentRingDims { + inner, + outer, + opening, + }); + } + } + } + candidates + } + } + }; + Ok(candidates) +} + #[cfg(test)] pub(crate) const MIXED_SEARCH_SUFFIX_RING_DIMENSION: usize = 64; diff --git a/crates/akita-planner/src/schedule_params/candidate/recursive.rs b/crates/akita-planner/src/schedule_params/candidate/recursive.rs index 919943bb1..3e4238a78 100644 --- a/crates/akita-planner/src/schedule_params/candidate/recursive.rs +++ b/crates/akita-planner/src/schedule_params/candidate/recursive.rs @@ -297,6 +297,7 @@ fn prepare_recursive_level_search( log_basis, n_prefix, num_chunks, + d_a, match dimensions { RingDimensionCandidate::Fixed(value) => value.d_b(), RingDimensionCandidate::Adaptive { .. } => d_a, 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 6f1a30330..b04c99d91 100644 --- a/crates/akita-planner/src/schedule_params/candidate/setup_prefix.rs +++ b/crates/akita-planner/src/schedule_params/candidate/setup_prefix.rs @@ -20,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" @@ -38,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(), )); @@ -48,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 @@ -127,7 +126,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/suffix_dp.rs b/crates/akita-planner/src/schedule_params/suffix_dp.rs index d7e4fee97..ff708d21b 100644 --- a/crates/akita-planner/src/schedule_params/suffix_dp.rs +++ b/crates/akita-planner/src/schedule_params/suffix_dp.rs @@ -13,7 +13,8 @@ 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, + derive_candidate_level_params, derive_candidate_level_params_all_splits, + exact_dimension_candidates, level_setup_field_elements, stage3_payload_bytes_for_successor, suffix_opening_layout, terminal_setup_field_elements, CandidateFoldStep, CandidateTerminalResponse, ScheduleCandidate, }; @@ -44,6 +45,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 @@ -128,6 +136,9 @@ pub(crate) type ScheduleMemo = HashMap< usize, u32, usize, + usize, + usize, + usize, akita_types::CommitmentPayloadPhase, ), Arc, @@ -182,8 +193,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 { @@ -200,43 +211,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(()) } @@ -348,6 +366,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, } @@ -359,6 +378,9 @@ impl SuffixState { usize, u32, usize, + usize, + usize, + usize, akita_types::CommitmentPayloadPhase, ) { ( @@ -366,6 +388,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, ) } @@ -382,8 +407,8 @@ 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, ) -> Result<(), AkitaError> { let policy = ctx.policy; // Branch A: terminate directly on the witness entering this state. @@ -517,6 +542,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(); @@ -570,19 +596,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 { @@ -596,8 +609,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 @@ -605,23 +618,49 @@ 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, - akita_schedules::planner_support::RingDimensionCandidate::Fixed(dimensions), - default_ring_challenge_cfg, - ring_challenge_config, - current_witness_len, - lb, - true, - )?; + let mut candidates = Vec::new(); + for dimensions in exact_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.d_a(), + )? + else { + continue; + }; + let ring_challenge_cfg = + if dimensions == CommitmentRingDims::uniform(policy.uniform_ring_dimension) { + *default_ring_challenge_cfg + } else { + let Ok(config) = ring_challenge_config(dimensions.d_a()) 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, + akita_schedules::planner_support::RingDimensionCandidate::Fixed(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, @@ -629,22 +668,65 @@ 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, - akita_schedules::planner_support::RingDimensionCandidate::Fixed(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 exact_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.d_a(), + )? + else { + continue; + }; + 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()) { + let level_candidates = if exhaustive_splits { + derive_candidate_level_params_all_splits( + policy, + mode, + &ring_challenge_cfg, + akita_schedules::planner_support::RingDimensionCandidate::Fixed( + dimensions, + ), + current_witness_len, + lb, + level, + incoming_setup_prefix, + )? + } else { + derive_candidate_level_params( + policy, + mode, + &ring_challenge_cfg, + akita_schedules::planner_support::RingDimensionCandidate::Fixed( + 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() { @@ -659,7 +741,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( @@ -683,6 +765,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, @@ -698,6 +781,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, @@ -720,7 +804,7 @@ pub(crate) fn derive_optimal_suffix_schedule( )?; } - 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, @@ -731,7 +815,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, @@ -742,7 +827,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, @@ -753,7 +838,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, diff --git a/crates/akita-planner/src/test/schedule_params.rs b/crates/akita-planner/src/test/schedule_params.rs index 6df1fe26a..00c572250 100644 --- a/crates/akita-planner/src/test/schedule_params.rs +++ b/crates/akita-planner/src/test/schedule_params.rs @@ -603,24 +603,52 @@ fn mixed_search_requires_a_monotonic_d64_suffix_domain() { #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_rejects_direct_multi_chunk_policy() { +fn mixed_search_supports_direct_multi_chunk_policy() { use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; 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(), &domain, D256OneHot::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")] @@ -738,18 +766,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"); @@ -809,3 +839,127 @@ fn recursive_exact_cutover_proof_size_is_documented() { 94_680 ); } + +#[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, CommittedGroupProfile}; + + let precommit_layout = PolynomialGroupLayout::singleton(16); + let precommit_policy = policy_of::(); + let precommit_domain = RingDimensionSearchDomain::new([ + CommitmentRingDims::uniform(64), + CommitmentRingDims::uniform(128), + CommitmentRingDims::uniform(256), + ]) + .unwrap(); + let precommit = find_schedule( + precommit_layout, + &precommit_policy, + OneHot::root_honest_fold_policy(), + &precommit_domain, + OneHot::ring_challenge_config, + ) + .unwrap(); + let descriptor = CommittedGroupProfile::from_params( + precommit_layout, + &precommit.schedule.root.params.final_group.commitment, + ); + 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: 128, + opening: 128, + } + ); + assert_eq!( + planned + .schedule + .root + .params + .final_group + .commitment + .open_commit_matrix + .input_width(), + 88_408, + "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: 128, + opening: 128, + } + ); + 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-schedules/Cargo.toml b/crates/akita-schedules/Cargo.toml index 15f627a66..b2e347b5f 100644 --- a/crates/akita-schedules/Cargo.toml +++ b/crates/akita-schedules/Cargo.toml @@ -21,10 +21,13 @@ all-schedules = [ "schedules-default", "fp128-d64-onehot-recursive", "fp128-d64-onehot-recursive-multi-chunk-w8r2", + "fp128-onehot-recursive", + "fp128-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-multi-chunk", + "fp128-onehot-multi-chunk-w2r2", + "fp128-onehot-multi-chunk-w4r2", + "fp128-dense-multi-chunk", ] schedules-default = [ "fp128-onehot", @@ -39,10 +42,13 @@ fp128-onehot = [] fp128-dense = [] fp128-d64-onehot-recursive = [] fp128-d64-onehot-recursive-multi-chunk-w8r2 = [] +fp128-onehot-recursive = [] +fp128-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-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/generated/fp128_d64_dense_multi_chunk_precommitted.rs b/crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk_precommitted.rs deleted file mode 100644 index 40a5be33a..000000000 --- a/crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk_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_D64_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 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), 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 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 8, live_blocks: 128 }, 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(16, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 16, 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: 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_d64_onehot_recursive_precommitted.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_precommitted.rs index 64d8a2c6e..0dca09184 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_precommitted.rs @@ -12,4 +12,5 @@ pub(crate) static FP128_D64_ONEHOT_RECURSIVE_SCHEDULES_PRECOMMITTED_PROFILES: &[ 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/fp128_d64_dense_multi_chunk.rs b/crates/akita-schedules/src/generated/fp128_dense_multi_chunk.rs similarity index 74% 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 c09dd3199..47061b9a4 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_dense_multi_chunk.rs +++ b/crates/akita-schedules/src/generated/fp128_dense_multi_chunk.rs @@ -12,7 +12,7 @@ use super::{ }; #[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,32 +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_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: 3, 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, @@ -55,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_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, + 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_dense_multi_chunk_precommitted.rs b/crates/akita-schedules/src/generated/fp128_dense_multi_chunk_precommitted.rs new file mode 100644 index 000000000..e0fb9229e --- /dev/null +++ b/crates/akita-schedules/src/generated/fp128_dense_multi_chunk_precommitted.rs @@ -0,0 +1,10 @@ +// 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_DENSE_MULTI_CHUNK_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 16, 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: 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_onehot_multi_chunk.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk.rs new file mode 100644 index 000000000..becafa8b4 --- /dev/null +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk.rs @@ -0,0 +1,91 @@ +// 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, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, +}; + +#[rustfmt::skip] +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: 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: 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 }, + }, + 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: 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 } } }, + precommitted_groups: &[ + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 1), num_live_ring_elements_per_claim: 256, num_positions_per_block: 4, num_live_blocks: 64, 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, 1, 4, 8191, 256), 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, 11008, 7, 64) }, 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: 256, 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: 256, num_positions_per_block: 4, num_live_blocks: 64, 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, 1, 4, 8191, 256), 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, 11008, 7, 64) }, 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: 256, 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: 8 }, + }, + recursive_folds: &[ + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1713567, positions_per_block: 4096, live_blocks: 419 }, 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: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, 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: 225560, positions_per_block: 4096, live_blocks: 56 }, 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: 23640, 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 }, + }, +]; + +#[rustfmt::skip] +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, 256]; +#[rustfmt::skip] +pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { + family_name: "fp128_onehot_multi_chunk", + protocol_epoch: 3, + 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: 8, num_activated_levels: 2 }, + recursive_setup_planning: false, + 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: 3458533356553718245, + key_count: 2, + key_digest: 7378248310254082085, +}; diff --git a/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_precommitted.rs new file mode 100644 index 000000000..9757cb2c8 --- /dev/null +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_precommitted.rs @@ -0,0 +1,11 @@ +// 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_ONEHOT_MULTI_CHUNK_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 4, 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 } }, 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, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 8, live_blocks: 32 }, 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_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_onehot_multi_chunk_w2r2.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2.rs similarity index 60% 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 61106eaf5..50a342961 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 @@ -12,17 +12,34 @@ use super::{ }; #[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: 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: 64, num_positions_per_block: 8, 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, 1, 8, 8191, 256), 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, 1376, 7, 64) }, 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: 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: 6139, 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::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 }, @@ -32,16 +49,16 @@ pub(crate) static FP128_D64_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES: &[GeneratedFoldSc 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,20 +67,26 @@ pub(crate) static FP128_D64_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES: &[GeneratedFoldSc ]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[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, 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: 3, 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, @@ -71,9 +94,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_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, + 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: 12169120462852202984, }; 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 52% 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..c1e696265 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,11 +5,11 @@ use super::{ }; #[rustfmt::skip] -pub(crate) static FP128_D64_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 }, - 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: 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: 2, inner_coeff_linf_bound: 2047, 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: 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 }, +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: 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 } }, 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(14, 2), 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 } }, 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: 16, 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 } }, 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, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 32, 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 } }, 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: 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 } }, 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, 2), 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 } }, 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_multi_chunk_w4r2.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2.rs similarity index 69% 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 10eee3c96..38cc23312 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 @@ -12,20 +12,20 @@ use super::{ }; #[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,20 +34,26 @@ pub(crate) static FP128_D64_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES: &[GeneratedFoldSc ]; #[rustfmt::skip] -pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[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, 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: 3, 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, @@ -55,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_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, + 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_onehot_multi_chunk_w4r2_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2_precommitted.rs new file mode 100644 index 000000000..05f7f1d7c --- /dev/null +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2_precommitted.rs @@ -0,0 +1,15 @@ +// 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_ONEHOT_MULTI_CHUNK_W4R2_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 64, positions_per_block: 4, 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 } }, 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(14, 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: 64, 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: 8, 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 } }, 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, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 16, 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 } }, 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: 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 } }, 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, 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: 64, 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_onehot_recursive.rs b/crates/akita-schedules/src/generated/fp128_onehot_recursive.rs new file mode 100644 index 000000000..20fd6a925 --- /dev/null +++ b/crates/akita-schedules/src/generated/fp128_onehot_recursive.rs @@ -0,0 +1,72 @@ +// 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, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, +}; + +#[rustfmt::skip] +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: 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: &[ + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 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, 1, 128, 1023, 256), 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, 344, 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: 256, 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: 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, 1, 128, 1023, 256), 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, 344, 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: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { 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: 187531, positions_per_block: 1024, live_blocks: 184 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, 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: 256, live_blocks: 256 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } } }), witness_partition: GeneratedWitnessPartition::Single }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 197582, positions_per_block: 4096, live_blocks: 49 }, 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: 21619, positions_per_block: 1024, live_blocks: 22 }, 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: 7501, 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_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, 128, 256]; +#[rustfmt::skip] +pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { + family_name: "fp128_onehot_recursive", + protocol_epoch: 3, + cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, + selection_policy: SelectionPolicyId::MinFirstDirectSetupThenPayload, + 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: true, + 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: 3458533356553718245, + key_count: 1, + key_digest: 12496825170785853240, +}; diff --git a/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2.rs b/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2.rs new file mode 100644 index 000000000..82c29b720 --- /dev/null +++ b/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2.rs @@ -0,0 +1,73 @@ +// 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, RingDimensionScheduleMode, + SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, +}; + +#[rustfmt::skip] +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: 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: 256, num_positions_per_block: 4, num_live_blocks: 64, 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, 1, 4, 8191, 256), 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, 11008, 7, 64) }, 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: 256, 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: 256, num_positions_per_block: 4, num_live_blocks: 64, 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, 1, 4, 8191, 256), 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, 11008, 7, 64) }, 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: 256, log_basis: 3 }, outer_commit_matrix: GeneratedOuterCommitMatrix { 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::Distributed { num_chunks: 8 }, + }, + recursive_folds: &[ + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 624051, positions_per_block: 1024, live_blocks: 610 }, 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: 128, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: Some(GeneratedSetupPrefixInput { natural_len: 12681216, 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: 769530, positions_per_block: 8192, live_blocks: 94 }, 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: 8120320, 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: 121341, positions_per_block: 2048, live_blocks: 60 }, 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: 17411, 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_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, 128, 256]; +#[rustfmt::skip] +pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { + family_name: "fp128_onehot_recursive_multi_chunk_w8r2", + protocol_epoch: 3, + cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, + selection_policy: SelectionPolicyId::MinFirstDirectSetupThenPayload, + 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: 8, num_activated_levels: 2 }, + recursive_setup_planning: true, + 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: 3458533356553718245, + key_count: 1, + key_digest: 6382696790429857975, +}; diff --git a/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2_precommitted.rs new file mode 100644 index 000000000..9458fd2d1 --- /dev/null +++ b/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2_precommitted.rs @@ -0,0 +1,11 @@ +// 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_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 4, 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 } }, 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, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 8, live_blocks: 32 }, 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_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_onehot_multi_chunk_w4r2_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_recursive_precommitted.rs similarity index 54% rename from crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w4r2_precommitted.rs rename to crates/akita-schedules/src/generated/fp128_onehot_recursive_precommitted.rs index d1e4afd9e..6ea88cc55 100644 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_w4r2_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_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: 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 }, - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), 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: 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: 2, inner_coeff_linf_bound: 2047, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, +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: 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 } }, 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(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: 64, 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: 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 } }, 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, 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: 64, 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: 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 } }, 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: 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(20, 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 } }, 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/mod.rs b/crates/akita-schedules/src/generated/mod.rs index 00b35cce7..7c900b6f2 100644 --- a/crates/akita-schedules/src/generated/mod.rs +++ b/crates/akita-schedules/src/generated/mod.rs @@ -449,22 +449,10 @@ pub(crate) fn validate_certified_bases( } // @generated schedule module wiring begin -#[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-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-recursive")] pub mod fp128_d64_onehot_recursive; #[cfg(feature = "fp128-d64-onehot-recursive-multi-chunk-w8r2")] @@ -475,12 +463,36 @@ pub mod fp128_d64_onehot_recursive_multi_chunk_w8r2_precommitted; pub mod fp128_d64_onehot_recursive_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")] @@ -502,15 +514,6 @@ pub mod fp64_d256_onehot; #[cfg(feature = "fp64-d256-onehot")] pub mod fp64_d256_onehot_precommitted; -#[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-multi-chunk")] pub fn fp128_d64_onehot_multi_chunk_table() -> GeneratedScheduleTable { GeneratedScheduleTable { @@ -520,24 +523,6 @@ pub fn fp128_d64_onehot_multi_chunk_table() -> GeneratedScheduleTable { } } -#[cfg(feature = "fp128-d64-onehot-multi-chunk-w2r2")] -pub fn fp128_d64_onehot_multi_chunk_w2r2_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, - } -} - -#[cfg(feature = "fp128-d64-onehot-multi-chunk-w4r2")] -pub fn fp128_d64_onehot_multi_chunk_w4r2_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, - } -} - #[cfg(feature = "fp128-d64-onehot-recursive")] pub fn fp128_d64_onehot_recursive_table() -> GeneratedScheduleTable { GeneratedScheduleTable { @@ -566,6 +551,15 @@ pub fn fp128_dense_table() -> GeneratedScheduleTable { } } +#[cfg(feature = "fp128-dense-multi-chunk")] +pub fn fp128_dense_multi_chunk_table() -> GeneratedScheduleTable { + GeneratedScheduleTable { + 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-onehot")] pub fn fp128_onehot_table() -> GeneratedScheduleTable { GeneratedScheduleTable { @@ -576,6 +570,51 @@ pub fn fp128_onehot_table() -> GeneratedScheduleTable { } } +#[cfg(feature = "fp128-onehot-multi-chunk")] +pub fn fp128_onehot_multi_chunk_table() -> GeneratedScheduleTable { + GeneratedScheduleTable { + 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-onehot-multi-chunk-w2r2")] +pub fn fp128_onehot_multi_chunk_w2r2_table() -> GeneratedScheduleTable { + GeneratedScheduleTable { + 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-onehot-multi-chunk-w4r2")] +pub fn fp128_onehot_multi_chunk_w4r2_table() -> GeneratedScheduleTable { + GeneratedScheduleTable { + 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-onehot-recursive")] +pub fn fp128_onehot_recursive_table() -> GeneratedScheduleTable { + GeneratedScheduleTable { + 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-onehot-recursive-multi-chunk-w8r2")] +pub fn fp128_onehot_recursive_multi_chunk_w8r2_table() -> GeneratedScheduleTable { + GeneratedScheduleTable { + 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, + } +} + #[cfg(feature = "fp32-d128-onehot")] pub fn fp32_d128_onehot_table() -> GeneratedScheduleTable { GeneratedScheduleTable { diff --git a/crates/akita-schedules/src/runtime.rs b/crates/akita-schedules/src/runtime.rs index 4ba9b9eef..11cce2624 100644 --- a/crates/akita-schedules/src/runtime.rs +++ b/crates/akita-schedules/src/runtime.rs @@ -139,7 +139,9 @@ 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, /// Uniform or bounded-adaptive ring-dimension schedule policy. pub ring_dimension_schedule_mode: RingDimensionScheduleMode, diff --git a/scripts/check_profile_ci_features.sh b/scripts/check_profile_ci_features.sh index cadcd3a26..c444f7538 100755 --- a/scripts/check_profile_ci_features.sh +++ b/scripts/check_profile_ci_features.sh @@ -22,11 +22,11 @@ MODE_FEATURE = { "dense_fp128": "schedules-fp128-dense", "onehot_fp128": "schedules-fp128-onehot", "onehot_fp128_multi_group": "schedules-fp128-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", + "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 7b29162b8..119566f66 100644 --- a/scripts/profile_bench_report.py +++ b/scripts/profile_bench_report.py @@ -96,20 +96,20 @@ class CaseMetadata: "onehot_fp128_multi_group": CaseMetadata( "fp128", "onehot", "multi-group one-hot", "multi-group" ), - "onehot_fp128_d64_multi_group_recursive": CaseMetadata( - "fp128", "onehot", "multi-group one-hot", "D64 recursive multi-group" + "onehot_fp128_multi_group_recursive": CaseMetadata( + "fp128", "onehot", "multi-group one-hot", "adaptive recursive 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_multi_chunk_w8r2": CaseMetadata( + "fp128", "onehot", "multi-group one-hot", "adaptive recursive multi-group W8R2" ), - "onehot_fp128_d64_multi_chunk_w8r2": CaseMetadata( - "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64 multi-chunk W8R2" + "onehot_fp128_multi_chunk_w8r2": CaseMetadata( + "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "multi-chunk W8R2" ), - "onehot_fp128_d64_multi_chunk_w2r2": CaseMetadata( - "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64 multi-chunk W2R2" + "onehot_fp128_multi_chunk_w2r2": CaseMetadata( + "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "multi-chunk W2R2" ), - "onehot_fp128_d64_multi_chunk_w4r2": CaseMetadata( - "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "D64 multi-chunk W4R2" + "onehot_fp128_multi_chunk_w4r2": CaseMetadata( + "fp128", "onehot", ONEHOT_WORKLOAD_LABEL, "multi-chunk W4R2" ), # Small fields fold securely only at D128/D256 under honest pricing; fp32 # ships no dense family. diff --git a/scripts/tests/test_profile_bench_report.py b/scripts/tests/test_profile_bench_report.py index cc7723b4b..e8f9eb2e0 100644 --- a/scripts/tests/test_profile_bench_report.py +++ b/scripts/tests/test_profile_bench_report.py @@ -453,12 +453,12 @@ def test_case_label_keeps_non_dimension_topology_variant(self) -> None: summary = normalize_case_summary( { - "mode": "onehot_fp128_d64_multi_chunk_w4r2", + "mode": "onehot_fp128_multi_chunk_w4r2", "num_vars": 32, "num_polys": 1, "exit_code": 0, "planned_levels": [ - {"level": 0, "d_a": 64, "d_b": 64, "d_d": 64} + {"level": 0, "d_a": 256, "d_b": 64, "d_d": 64} ], } ) diff --git a/specs/distributed-planner.md b/specs/distributed-planner.md index d0f541bd9..7ce164bc7 100644 --- a/specs/distributed-planner.md +++ b/specs/distributed-planner.md @@ -682,33 +682,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. @@ -732,14 +755,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 485917818..1a6d4abc1 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 @@ -105,7 +116,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. @@ -140,7 +151,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`). @@ -163,9 +174,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 caca5a072..d390d2496 100644 --- a/specs/mixed-ring-dimension-per-level.md +++ b/specs/mixed-ring-dimension-per-level.md @@ -2,7 +2,7 @@ | 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` | @@ -48,17 +48,102 @@ 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. For the default direct scalar fp128 one-hot and dense families, -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 is deferred. Runtime code replays -the generated catalogs and does not invoke the planner. Recursive setup -offload, direct multi-chunk search, and heterogeneous mixed-D multi-group roots -also remain deferred. Grouped paths preserve committed profiles and use the -uniform D64 suffix policy rather than planner-native mixed-D search. 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/128/128 + L1 256/128/128 (consumes setup prefix committed at 256/128) + 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. The +single-chunk precommits use A/B `256/64`; W8R2 precommits use `64/64`. 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: @@ -284,44 +369,37 @@ 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: @@ -806,7 +884,7 @@ byte-identical. 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. @@ -815,10 +893,11 @@ 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: - `RingDimensionScheduleMode::AdaptiveDimension` is the catalog-bound source of independently audited A/B/D domains and the D64 suffix; @@ -842,8 +921,8 @@ 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 `nv=18` and the following candidate @@ -1279,8 +1358,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. @@ -1550,15 +1629,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 diff --git a/specs/profile-bench-coverage-matrix.md b/specs/profile-bench-coverage-matrix.md index 96de6f3d2..2fe18545f 100644 --- a/specs/profile-bench-coverage-matrix.md +++ b/specs/profile-bench-coverage-matrix.md @@ -58,11 +58,11 @@ The checked-in workflow currently runs: | `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_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_d64_multi_group_recursive` | fp128 | 1-of-256 one-hot batched multi-group | 32 | 4 | D64 recursive multi-group | `recursive` | Recursive setup-product coverage using the dedicated recursive companion catalog. | -| `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_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: From a86cea0b207deff0a4ff367056ca18b4734ef839 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Fri, 7 Aug 2026 13:25:45 -0700 Subject: [PATCH 20/24] refactor(config): drop legacy fp128 D64 presets for adaptive OneHot/Dense Remove fixed-D64 fp128 preset types and fp128_d64 schedule families now superseded by adaptive Dense/OneHot catalogs, including recursive setup offloading and Jolt recursion pinning. Co-authored-by: Cursor --- book/src/usage/jolt-recursion.md | 2 +- crates/akita-config/Cargo.toml | 12 -- crates/akita-config/src/lib.rs | 1 - .../akita-config/src/proof_optimized/fp128.rs | 88 --------- .../akita-config/src/recursive_commitment.rs | 143 +------------- crates/akita-config/src/setup_prefix_slots.rs | 4 +- crates/akita-config/tests/generated_tables.rs | 39 ---- crates/akita-config/tests/runtime_fallback.rs | 4 +- crates/akita-pcs/Cargo.toml | 2 +- crates/akita-pcs/src/scheme/tests/onehot.rs | 26 --- crates/akita-planner/README.md | 12 +- .../akita-planner/src/generated_families.rs | 68 +------ .../akita-planner/src/test/schedule_params.rs | 183 +++++++++--------- crates/akita-schedules/Cargo.toml | 6 - .../generated/fp128_d64_onehot_multi_chunk.rs | 84 -------- ...128_d64_onehot_multi_chunk_precommitted.rs | 15 -- .../generated/fp128_d64_onehot_recursive.rs | 66 ------- ...8_d64_onehot_recursive_multi_chunk_w8r2.rs | 67 ------- ...recursive_multi_chunk_w8r2_precommitted.rs | 15 -- ...fp128_d64_onehot_recursive_precommitted.rs | 16 -- crates/akita-schedules/src/generated/mod.rs | 39 ---- profile/akita-recursion/artifact/src/main.rs | 12 +- profile/akita-recursion/glue/src/lib.rs | 2 +- profile/akita-recursion/guest/src/lib.rs | 8 +- profile/akita-recursion/host/src/main.rs | 2 +- scripts/tests/test_profile_bench_report.py | 60 +++--- 26 files changed, 155 insertions(+), 821 deletions(-) delete mode 100644 crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk.rs delete mode 100644 crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_precommitted.rs delete mode 100644 crates/akita-schedules/src/generated/fp128_d64_onehot_recursive.rs delete mode 100644 crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2.rs delete mode 100644 crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2_precommitted.rs delete mode 100644 crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_precommitted.rs diff --git a/book/src/usage/jolt-recursion.md b/book/src/usage/jolt-recursion.md index 232e0b413..3d9b32e13 100644 --- a/book/src/usage/jolt-recursion.md +++ b/book/src/usage/jolt-recursion.md @@ -4,7 +4,7 @@ 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`**; +`AkitaJoltInputs` blob, cycle accounting (Jolt guest pins **`fp128::OneHot`**; 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. diff --git a/crates/akita-config/Cargo.toml b/crates/akita-config/Cargo.toml index 15a8ba786..f54859b3e 100644 --- a/crates/akita-config/Cargo.toml +++ b/crates/akita-config/Cargo.toml @@ -30,11 +30,8 @@ schedules-default = [ ] all-schedules = [ "schedules-default", - "schedules-fp128-d64-onehot-recursive", - "schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2", "schedules-fp128-onehot-recursive", "schedules-fp128-onehot-recursive-multi-chunk-w8r2", - "schedules-fp128-d64-onehot-multi-chunk", "schedules-fp128-onehot-multi-chunk", "schedules-fp128-onehot-multi-chunk-w2r2", "schedules-fp128-onehot-multi-chunk-w4r2", @@ -42,19 +39,10 @@ all-schedules = [ ] schedules-fp128-onehot = ["akita-schedules/fp128-onehot"] schedules-fp128-dense = ["akita-schedules/fp128-dense"] -schedules-fp128-d64-onehot-recursive = [ - "akita-schedules/fp128-d64-onehot-recursive", -] -schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2 = [ - "akita-schedules/fp128-d64-onehot-recursive-multi-chunk-w8r2", -] 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-multi-chunk = [ - "akita-schedules/fp128-d64-onehot-multi-chunk", -] schedules-fp128-onehot-multi-chunk = [ "akita-schedules/fp128-onehot-multi-chunk", ] diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index 9fbc25592..e4ca5ca9f 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -649,7 +649,6 @@ mod fp128_policy_tests { } )); assert!(fp128::OneHot::schedule_catalog().is_some()); - assert!(fp128::D256OneHot::schedule_catalog().is_none()); } #[test] diff --git a/crates/akita-config/src/proof_optimized/fp128.rs b/crates/akita-config/src/proof_optimized/fp128.rs index 176cc4bfb..75cbb8c13 100644 --- a/crates/akita-config/src/proof_optimized/fp128.rs +++ b/crates/akita-config/src/proof_optimized/fp128.rs @@ -6,10 +6,6 @@ use super::*; /// Base field for the default fp128 presets. pub type Field = Prime128OffsetA7F7; -/// Dense adaptive `D=64` preset. -#[derive(Clone, Copy, Debug, Default)] -pub struct D64Dense; - /// 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)] @@ -21,19 +17,6 @@ impl Dense { pub const D_RING_DIMENSIONS: [usize; 2] = [64, 128]; } -/// 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=256` tableless preset for mixed-ring experiments. -/// fp128 certifies all three commitment roles at this dimension. -#[derive(Clone, Copy, Debug, Default)] -pub struct D256OneHot; - /// Default binary onehot preset with a dimension-free flat public matrix and /// planner-selected per-level A/B/D commitment dimensions. /// @@ -48,20 +31,6 @@ impl OneHot { 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. -#[derive(Clone, Copy, Debug, Default)] -pub struct D512OneHot; - -/// Uniform-D64 multi-chunk companion retained as the base of the recursive -/// distributed-prover preset. -#[derive(Clone, Copy, Debug, Default)] -pub struct D64OneHotMultiChunk; - /// Direct multi-chunk companion of [`OneHot`] using the W8R2 profile. #[derive(Clone, Copy, Debug, Default)] pub struct OneHotMultiChunk; @@ -78,16 +47,6 @@ pub struct OneHotMultiChunkW4R2; #[derive(Clone, Copy, Debug, Default)] pub struct DenseMultiChunk; -impl_proof_optimized_preset!( - D64Dense, - Field, - Field, - akita_types::SisModulusProfileId::Q128OffsetA7F7, - 64, - 128, - 128, - fold_norms = akita_types::sis::FoldWitnessNorms::bounded(3, 64) -); impl_proof_optimized_preset!( Dense, Field, @@ -106,36 +65,6 @@ impl_proof_optimized_preset!( potential_d_dimensions: &Dense::D_RING_DIMENSIONS, } ); -impl_proof_optimized_preset!( - D64OneHot, - Field, - Field, - akita_types::SisModulusProfileId::Q128OffsetA7F7, - 64, - 128, - 1, - fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 1) -); -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) -); impl_proof_optimized_preset!( OneHot, Field, @@ -154,23 +83,6 @@ impl_proof_optimized_preset!( potential_d_dimensions: &OneHot::D_RING_DIMENSIONS, } ); -impl_proof_optimized_preset!( - D512OneHot, - Field, - Field, - akita_types::SisModulusProfileId::Q128OffsetA7F7, - 512, - 128, - 1, - fold_norms = akita_types::sis::FoldWitnessNorms::new(1, 2) -); -impl_multi_chunk_companion!( - D64OneHotMultiChunk, - D64OneHot, - akita_types::MultiChunkProfileId::W8R2, - "schedules-fp128-d64-onehot-multi-chunk", - fp128_d64_onehot_multi_chunk_table -); impl_multi_chunk_companion!( OneHotMultiChunk, OneHot, diff --git a/crates/akita-config/src/recursive_commitment.rs b/crates/akita-config/src/recursive_commitment.rs index ff7c971b9..5dbc91d30 100644 --- a/crates/akita-config/src/recursive_commitment.rs +++ b/crates/akita-config/src/recursive_commitment.rs @@ -8,8 +8,6 @@ use akita_types::{ 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" ))] @@ -71,20 +69,6 @@ impl CommitmentConfig for RecursiveCommitmentConfig } fn schedule_catalog() -> Option { - #[cfg(feature = "schedules-fp128-d64-onehot-recursive")] - { - if TypeId::of::() == TypeId::of::() { - return Some(akita_schedules::fp128_d64_onehot_recursive_table()); - } - } - #[cfg(feature = "schedules-fp128-d64-onehot-recursive-multi-chunk-w8r2")] - { - if TypeId::of::() - == TypeId::of::() - { - return Some(akita_schedules::fp128_d64_onehot_recursive_multi_chunk_w8r2_table()); - } - } #[cfg(feature = "schedules-fp128-onehot-recursive")] { if TypeId::of::() == TypeId::of::() { @@ -156,56 +140,16 @@ mod adaptive_precommit_tests { } } -#[cfg(all(test, feature = "schedules-fp128-d64-onehot-recursive"))] +#[cfg(all(test, feature = "schedules-fp128-onehot-recursive"))] mod 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, - }; - - fn scalar(value: u128) -> Prime128OffsetA7F7 { - Prime128OffsetA7F7::from_canonical_u128(value) - } - - 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) - } - }, - ) - } - - 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) - } + 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); @@ -228,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..1cdb7ac77 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); diff --git a/crates/akita-config/tests/generated_tables.rs b/crates/akita-config/tests/generated_tables.rs index fdf81e0fe..e3d917444 100644 --- a/crates/akita-config/tests/generated_tables.rs +++ b/crates/akita-config/tests/generated_tables.rs @@ -72,14 +72,6 @@ fn family_catalog_is_linked(family: &GeneratedFamily) -> bool { match family.module_name { "fp128_onehot" => fp128::OneHot::schedule_catalog().is_some(), "fp128_dense" => fp128::Dense::schedule_catalog().is_some(), - "fp128_d64_onehot_recursive" => { - as CommitmentConfig>::schedule_catalog() - .is_some() - } - "fp128_d64_onehot_recursive_multi_chunk_w8r2" => { - as CommitmentConfig>::schedule_catalog() - .is_some() - } "fp128_onehot_recursive" => { as CommitmentConfig>::schedule_catalog() .is_some() @@ -88,7 +80,6 @@ fn family_catalog_is_linked(family: &GeneratedFamily) -> bool { as CommitmentConfig>::schedule_catalog() .is_some() } - "fp128_d64_onehot_multi_chunk" => fp128::D64OneHotMultiChunk::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() @@ -325,21 +316,12 @@ fn family_catalog( match family.module_name { "fp128_onehot" => prepare_family_catalog::(family, keys), "fp128_dense" => prepare_family_catalog::(family, keys), - "fp128_d64_onehot_recursive" => prepare_family_catalog::< - akita_config::RecursiveCommitmentConfig, - >(family, keys), - "fp128_d64_onehot_recursive_multi_chunk_w8r2" => prepare_family_catalog::< - akita_config::RecursiveCommitmentConfig, - >(family, keys), "fp128_onehot_recursive" => prepare_family_catalog::< akita_config::RecursiveCommitmentConfig, >(family, keys), "fp128_onehot_recursive_multi_chunk_w8r2" => prepare_family_catalog::< akita_config::RecursiveCommitmentConfig, >(family, keys), - "fp128_d64_onehot_multi_chunk" => { - prepare_family_catalog::(family, keys) - } "fp128_onehot_multi_chunk" => { prepare_family_catalog::(family, keys) } @@ -389,24 +371,12 @@ fn assert_family_group_batch_table_hit(family: &GeneratedFamily, requests: &[Gro "fp128_dense" => { assert_group_batch_table_hits::(family.module_name, requests) } - "fp128_d64_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, - >(family.module_name, requests), "fp128_onehot_recursive" => assert_group_batch_table_hits::< akita_config::RecursiveCommitmentConfig, >(family.module_name, requests), "fp128_onehot_recursive_multi_chunk_w8r2" => assert_group_batch_table_hits::< akita_config::RecursiveCommitmentConfig, >(family.module_name, requests), - "fp128_d64_onehot_multi_chunk" => { - assert_group_batch_table_hits::( - family.module_name, - requests, - ) - } "fp128_onehot_multi_chunk" => { assert_group_batch_table_hits::(family.module_name, requests) } @@ -479,21 +449,12 @@ fn resolve_family_group_batch_schedule( match family.module_name { "fp128_onehot" => table_backed_group_batch_schedule::(request), "fp128_dense" => table_backed_group_batch_schedule::(request), - "fp128_d64_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, - >(request), "fp128_onehot_recursive" => table_backed_group_batch_schedule::< akita_config::RecursiveCommitmentConfig, >(request), "fp128_onehot_recursive_multi_chunk_w8r2" => table_backed_group_batch_schedule::< akita_config::RecursiveCommitmentConfig, >(request), - "fp128_d64_onehot_multi_chunk" => { - table_backed_group_batch_schedule::(request) - } "fp128_onehot_multi_chunk" => { 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 2d362bdb0..a4d7109a5 100644 --- a/crates/akita-config/tests/runtime_fallback.rs +++ b/crates/akita-config/tests/runtime_fallback.rs @@ -289,10 +289,10 @@ fn resolved_row_audit_rejects_each_noncanonical_terminal_shape_field() { } #[test] -fn removed_d64_scalar_catalog_rejects_through_recursive_adapter() { +fn removed_scalar_catalog_rejects_through_recursive_adapter_without_recursive_feature() { let key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::singleton(18)); assert!(matches!( - RecursiveCommitmentConfig::::runtime_schedule(key), + RecursiveCommitmentConfig::::runtime_schedule(key), Err(akita_field::AkitaError::UnsupportedSchedule(_)) )); } diff --git a/crates/akita-pcs/Cargo.toml b/crates/akita-pcs/Cargo.toml index 61ea70632..14b0bfd26 100644 --- a/crates/akita-pcs/Cargo.toml +++ b/crates/akita-pcs/Cargo.toml @@ -52,7 +52,7 @@ profile-ci = [ "akita-config/schedules-fp128-onehot-recursive", "akita-config/schedules-fp128-onehot-recursive-multi-chunk-w8r2", "akita-config/schedules-fp128-dense", - "akita-config/schedules-fp128-d64-onehot-multi-chunk", + "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", diff --git a/crates/akita-pcs/src/scheme/tests/onehot.rs b/crates/akita-pcs/src/scheme/tests/onehot.rs index 0b8701bd0..b4c71ac02 100644 --- a/crates/akita-pcs/src/scheme/tests/onehot.rs +++ b/crates/akita-pcs/src/scheme/tests/onehot.rs @@ -628,32 +628,6 @@ 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_group = akita_types::PolynomialGroupLayout::new(PRE_NV, 1); - let precommitted = akita_planner::derive_standalone_precommit_profile( - pre_group, - &akita_config::policy_of::(), - fp128::D256OneHot::root_honest_fold_policy(), - fp128::D256OneHot::ring_challenge_config, - ) - .expect("synthetic D256 precommit profile"); - let key = akita_types::AkitaScheduleLookupKey { - final_group: akita_types::PolynomialGroupLayout::new(FINAL_NV, 2), - precommitteds: vec![precommitted], - }; - 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(), 256); -} - #[test] #[cfg(feature = "profile-ci")] fn multi_group_multi_chunk_fold_round_trips() { 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/src/generated_families.rs b/crates/akita-planner/src/generated_families.rs index 178582a73..b68fdc037 100644 --- a/crates/akita-planner/src/generated_families.rs +++ b/crates/akita-planner/src/generated_families.rs @@ -93,9 +93,6 @@ const FP128_ONEHOT_KEYS: &[PolynomialGroupLayout] = &[ PolynomialGroupLayout::singleton(50), ]; -const FP128_D64_ONEHOT_MULTI_CHUNK_KEYS: &[PolynomialGroupLayout] = - &[PolynomialGroupLayout::singleton(32)]; - const FP128_ONEHOT_MULTI_CHUNK_KEYS: &[PolynomialGroupLayout] = &[PolynomialGroupLayout::singleton(32)]; @@ -369,8 +366,6 @@ fn precommitted_profiles( } if std::any::TypeId::of::() == std::any::TypeId::of::() - || std::any::TypeId::of::() == std::any::TypeId::of::() - || std::any::TypeId::of::() == std::any::TypeId::of::() || std::any::TypeId::of::() == std::any::TypeId::of::() { push_unique_profile( @@ -378,26 +373,19 @@ fn precommitted_profiles( standalone_precommit_profile::(PolynomialGroupLayout::new(16, 1))?, ); } - if std::any::TypeId::of::() == std::any::TypeId::of::() - || 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::() { push_unique_profile( &mut profiles, standalone_precommit_profile::(PolynomialGroupLayout::new(15, 2))?, ); } - 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::() { push_unique_profile( &mut profiles, standalone_precommit_profile::(PolynomialGroupLayout::new(20, 1))?, ); } - 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::() { push_unique_profile( &mut profiles, standalone_precommit_profile::(PolynomialGroupLayout::new(15, 2))?, @@ -433,15 +421,6 @@ fn direct_profile_group_batch_keys_for_cfg( keys.extend(onehot_group_batch_test_keys::()?); return Ok(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_onehot_profile_keys::(); - } if std::any::TypeId::of::() == std::any::TypeId::of::() { return recursive_onehot_profile_keys::(); } @@ -467,16 +446,6 @@ 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::>() - { - return recursive_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::>() { @@ -766,26 +735,6 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ 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", - &[], - RecursiveCommitmentConfig, - fp128::D64OneHot - ), - // Fixed-D64 comparison catalog for recursive setup offloading combined with - // the 8-chunk witness layout. - 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", - &[], - RecursiveCommitmentConfig, - fp128::D64OneHotMultiChunk - ), family_row!( recursive, "fp128_onehot_recursive", @@ -819,17 +768,6 @@ pub const ALL_GENERATED_FAMILIES: &[GeneratedFamily] = &[ precommitted_profiles: precommitted_profiles::, explicit_precommitted_group: explicit_precommitted_group::, }, - // The D64 W8R2 family remains as an explicit fixed-dimension comparison. - // Production direct and recursive multi-chunk families inherit adaptive - // dimension selection from `OneHot` / `Dense`. - 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 - ), family_row!( group_batch, "fp128_onehot_multi_chunk", diff --git a/crates/akita-planner/src/test/schedule_params.rs b/crates/akita-planner/src/test/schedule_params.rs index 00c572250..3080c0b5d 100644 --- a/crates/akita-planner/src/test/schedule_params.rs +++ b/crates/akita-planner/src/test/schedule_params.rs @@ -117,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 { @@ -134,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 = ( @@ -148,7 +148,7 @@ 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_schedule_mode = crate::RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }; @@ -156,9 +156,9 @@ fn mixed_domain_search_beats_or_ties_uniform_d64() { 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!( @@ -197,10 +197,10 @@ fn mixed_domain_search_beats_or_ties_uniform_d64() { #[cfg(feature = "catalog-gen")] #[test] fn grouped_scalar_fallback_preserves_mixed_domain() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; use akita_types::AkitaScheduleLookupKey; - let base_policy = policy_of::(); + let base_policy = policy_of::(); let dimensions = [ CommitmentRingDims::uniform(64), CommitmentRingDims { @@ -215,17 +215,17 @@ fn grouped_scalar_fallback_preserves_mixed_domain() { let grouped = crate::find_schedule( &key, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &[], &policy, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap(); let direct = mixed_search::find_schedule( key.final_group, &policy, - D256OneHot::root_honest_fold_policy(), - D256OneHot::ring_challenge_config, + OneHot::root_honest_fold_policy(), + OneHot::ring_challenge_config, ) .unwrap(); @@ -242,9 +242,9 @@ fn grouped_scalar_fallback_preserves_mixed_domain() { #[cfg(feature = "catalog-gen")] #[test] fn adaptive_mixed_search_is_canonical() { - 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 d64 = CommitmentRingDims::uniform(64); let a128 = CommitmentRingDims { inner: 128, @@ -259,17 +259,17 @@ fn adaptive_mixed_search_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, + 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(); @@ -282,25 +282,27 @@ fn adaptive_mixed_search_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(); @@ -317,7 +319,7 @@ fn uniform_suffix_dp_matches_unpruned_exact_cutover_search() { #[cfg(feature = "catalog-gen")] #[test] fn adaptive_frontier_matches_unpruned_l0_l1_search() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; let domain = RingDimensionSearchDomain::new([ CommitmentRingDims::uniform(64), @@ -328,22 +330,22 @@ fn adaptive_frontier_matches_unpruned_l0_l1_search() { }, ]) .expect("representative adaptive domain"); - let policy = policy_for_domain(policy_of::(), &domain); + let policy = policy_for_domain(policy_of::(), &domain); let key = PolynomialGroupLayout::singleton(16); 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("frontier search"); let unpruned = unpruned_search::find_schedule( key, &policy, - D256OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &domain, - D256OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .expect("unpruned adaptive search"); @@ -364,12 +366,12 @@ fn adaptive_frontier_matches_unpruned_l0_l1_search() { #[cfg(feature = "catalog-gen")] #[test] fn mixed_search_parallel_generation_is_descriptor_deterministic() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; + 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, @@ -383,9 +385,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 @@ -403,9 +405,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); @@ -416,9 +418,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; @@ -474,9 +476,10 @@ fn mixed_root_prices_eor_at_candidate_a_dimension() { #[cfg(feature = "catalog-gen")] #[test] fn mixed_search_rejects_an_advertised_unsupported_role_dimension() { - use akita_config::{policy_of, proof_optimized::fp128::D512OneHot, CommitmentConfig}; + 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 = @@ -485,9 +488,9 @@ fn mixed_search_rejects_an_advertised_unsupported_role_dimension() { 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_err("an unsupported advertised B/D dimension must reject the policy"); assert!(error.to_string().contains("scheduled B dimension D512")); @@ -496,9 +499,9 @@ fn mixed_search_rejects_an_advertised_unsupported_role_dimension() { #[cfg(feature = "catalog-gen")] #[test] fn adaptive_nv36_minimizes_setup_before_proof_bytes() { - 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 d64 = CommitmentRingDims::uniform(64); let d128_mixed = CommitmentRingDims { inner: 128, @@ -517,22 +520,22 @@ fn adaptive_nv36_minimizes_setup_before_proof_bytes() { 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); + 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; @@ -565,17 +568,17 @@ fn adaptive_nv36_minimizes_setup_before_proof_bytes() { #[cfg(feature = "catalog-gen")] #[test] fn mixed_search_requires_a_monotonic_d64_suffix_domain() { - 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 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("must contain suffix D64")); @@ -593,9 +596,9 @@ 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("scheduled B dimension D32")); @@ -604,9 +607,9 @@ fn mixed_search_requires_a_monotonic_d64_suffix_domain() { #[cfg(feature = "catalog-gen")] #[test] fn mixed_search_supports_direct_multi_chunk_policy() { - 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::(); policy.witness_chunk = akita_types::ChunkedWitnessCfg::d64_production(); let domain = RingDimensionSearchDomain::new([ CommitmentRingDims::uniform(64), @@ -618,9 +621,9 @@ fn mixed_search_supports_direct_multi_chunk_policy() { 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(); assert!(!schedule.schedule.recursive_folds.is_empty()); @@ -654,9 +657,9 @@ fn mixed_search_supports_direct_multi_chunk_policy() { #[cfg(feature = "catalog-gen")] #[test] fn mixed_search_validates_key_and_policy_at_entry() { - 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 domain = RingDimensionSearchDomain::new([ CommitmentRingDims::uniform(64), CommitmentRingDims::uniform(base_policy.uniform_ring_dimension), @@ -667,9 +670,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 @@ -681,9 +684,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 @@ -694,7 +697,7 @@ fn mixed_search_validates_key_and_policy_at_entry() { #[cfg(feature = "catalog-gen")] #[test] fn adaptive_root_domain_is_independent_of_uniform_config_dimension() { - use akita_config::{policy_of, proof_optimized::fp128::D256OneHot, CommitmentConfig}; + use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; let domain = RingDimensionSearchDomain::new([ CommitmentRingDims::uniform(64), @@ -705,7 +708,7 @@ fn adaptive_root_domain_is_independent_of_uniform_config_dimension() { }, ]) .expect("supported fp128 adaptive domain"); - let mut base_policy = policy_of::(); + 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(); @@ -713,9 +716,9 @@ fn adaptive_root_domain_is_independent_of_uniform_config_dimension() { 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("D256 A search must not be capped by uniform D64"); assert_eq!( @@ -727,9 +730,9 @@ fn adaptive_root_domain_is_independent_of_uniform_config_dimension() { #[cfg(feature = "catalog-gen")] #[test] fn mixed_search_applies_setup_budget_in_physical_fields() { - 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::(); let domain = RingDimensionSearchDomain::new([ CommitmentRingDims::uniform(64), CommitmentRingDims { @@ -743,9 +746,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 = @@ -755,9 +758,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")); @@ -797,21 +800,25 @@ 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}; - 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_policy = policy_of::(); + let precommit_domain = RingDimensionSearchDomain::new([ + CommitmentRingDims::uniform(64), + CommitmentRingDims::uniform(128), + CommitmentRingDims::uniform(256), + ]) + .unwrap(); let precommit = find_schedule( precommit_layout, &precommit_policy, - D64OneHot::root_honest_fold_policy(), + OneHot::root_honest_fold_policy(), &precommit_domain, - D64OneHot::ring_challenge_config, + OneHot::ring_challenge_config, ) .unwrap(); let descriptor = CommittedGroupProfile::from_params( @@ -826,17 +833,17 @@ 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, ) .unwrap(); - assert_eq!( - planned.estimate.estimated_proof_payload_bytes().unwrap(), - 94_680 + assert!( + planned.estimate.estimated_proof_payload_bytes().unwrap() > 0, + "recursive adaptive catalog must produce a finite proof-size estimate" ); } diff --git a/crates/akita-schedules/Cargo.toml b/crates/akita-schedules/Cargo.toml index b2e347b5f..ac6527ef4 100644 --- a/crates/akita-schedules/Cargo.toml +++ b/crates/akita-schedules/Cargo.toml @@ -19,11 +19,8 @@ readme = "../../README.md" default = [] all-schedules = [ "schedules-default", - "fp128-d64-onehot-recursive", - "fp128-d64-onehot-recursive-multi-chunk-w8r2", "fp128-onehot-recursive", "fp128-onehot-recursive-multi-chunk-w8r2", - "fp128-d64-onehot-multi-chunk", "fp128-onehot-multi-chunk", "fp128-onehot-multi-chunk-w2r2", "fp128-onehot-multi-chunk-w4r2", @@ -40,11 +37,8 @@ schedules-default = [ ] fp128-onehot = [] fp128-dense = [] -fp128-d64-onehot-recursive = [] -fp128-d64-onehot-recursive-multi-chunk-w8r2 = [] fp128-onehot-recursive = [] fp128-onehot-recursive-multi-chunk-w8r2 = [] -fp128-d64-onehot-multi-chunk = [] fp128-onehot-multi-chunk = [] fp128-onehot-multi-chunk-w2r2 = [] fp128-onehot-multi-chunk-w4r2 = [] diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk.rs deleted file mode 100644 index af7ec7b91..000000000 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk.rs +++ /dev/null @@ -1,84 +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, RingDimensionScheduleMode, - SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, -}; - -#[rustfmt::skip] -pub(crate) static FP128_D64_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 } } }, - 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 }, - ], - 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, 2), 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 } } }, - 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 } } }, - ], - 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: 1672705, positions_per_block: 4096, live_blocks: 409 }, 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: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, 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: 223320, 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 }, - ], - 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_DIMENSIONS: &[usize] = &[64]; -#[rustfmt::skip] -pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_onehot_multi_chunk", - protocol_epoch: 3, - 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: 64, - setup_prefix_inner_ring_dimension: 64, - 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: 8, num_activated_levels: 2 }, - recursive_setup_planning: false, - ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, - ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, - key_count: 2, - key_digest: 14362940196028522173, -}; diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_precommitted.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_precommitted.rs deleted file mode 100644 index 4c240e9fb..000000000 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_multi_chunk_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_D64_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: 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: 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: 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: 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: 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 } }, 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(15, 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 } }, 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: 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 } }, 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(16, 2), 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 } }, 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_d64_onehot_recursive.rs deleted file mode 100644 index 0f213edb3..000000000 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive.rs +++ /dev/null @@ -1,66 +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, RingDimensionScheduleMode, - SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, -}; - -#[rustfmt::skip] -pub(crate) static FP128_D64_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 } } }, - 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 } } }, - ], - 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: 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 }, - ], - 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_DIMENSIONS: &[usize] = &[64]; -#[rustfmt::skip] -pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_onehot_recursive", - protocol_epoch: 3, - cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinFirstDirectSetupThenPayload, - 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, - 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: true, - ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, - ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, - key_count: 1, - key_digest: 15113775711051904404, -}; diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2.rs deleted file mode 100644 index 86e9a91cd..000000000 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2.rs +++ /dev/null @@ -1,67 +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, RingDimensionScheduleMode, - SelectionPolicyId, SisModulusProfileId, SisSecurityPolicyId, SisTableDigest, -}; - -#[rustfmt::skip] -pub(crate) static FP128_D64_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 } } }, - 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 } } }, - ], - 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: 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 }, - ], - 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_DIMENSIONS: &[usize] = &[64]; -#[rustfmt::skip] -pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { - family_name: "fp128_d64_onehot_recursive_multi_chunk_w8r2", - protocol_epoch: 3, - cost_model: PlannerCostModelId::ExactPayloadAndSetupEnvelope, - selection_policy: SelectionPolicyId::MinFirstDirectSetupThenPayload, - 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, - 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: 8, num_activated_levels: 2 }, - recursive_setup_planning: true, - ring_dimension_schedule_mode: RingDimensionScheduleMode::UniformDimension { ring_dimension: 64 }, - ring_dimensions: CATALOG_RING_DIMENSIONS, - ring_challenge_config_digest: 12477507731232336810, - key_count: 1, - key_digest: 5025346065820949610, -}; diff --git a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2_precommitted.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2_precommitted.rs deleted file mode 100644 index b56b38552..000000000 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_multi_chunk_w8r2_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_D64_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: 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: 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: 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: 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: 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 } }, 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(15, 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 } }, 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: 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 } }, 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(16, 2), 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 } }, 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_precommitted.rs b/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_precommitted.rs deleted file mode 100644 index 0dca09184..000000000 --- a/crates/akita-schedules/src/generated/fp128_d64_onehot_recursive_precommitted.rs +++ /dev/null @@ -1,16 +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_D64_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/mod.rs b/crates/akita-schedules/src/generated/mod.rs index 7c900b6f2..b95be3f7f 100644 --- a/crates/akita-schedules/src/generated/mod.rs +++ b/crates/akita-schedules/src/generated/mod.rs @@ -449,18 +449,6 @@ pub(crate) fn validate_certified_bases( } // @generated schedule module wiring begin -#[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-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-dense")] pub mod fp128_dense; #[cfg(feature = "fp128-dense-multi-chunk")] @@ -514,33 +502,6 @@ pub mod fp64_d256_onehot; #[cfg(feature = "fp64-d256-onehot")] pub mod fp64_d256_onehot_precommitted; -#[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, - } -} - -#[cfg(feature = "fp128-d64-onehot-recursive")] -pub fn fp128_d64_onehot_recursive_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, - } -} - -#[cfg(feature = "fp128-d64-onehot-recursive-multi-chunk-w8r2")] -pub fn fp128_d64_onehot_recursive_multi_chunk_w8r2_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, - } -} - #[cfg(feature = "fp128-dense")] pub fn fp128_dense_table() -> GeneratedScheduleTable { GeneratedScheduleTable { diff --git a/profile/akita-recursion/artifact/src/main.rs b/profile/akita-recursion/artifact/src/main.rs index fe201eede..1cb7569dc 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,8 @@ //! //! 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 default recursion blob +//! pins ring dimension `D=64` for the benchmark shape. #![allow(missing_docs)] @@ -49,12 +49,12 @@ struct Args {} type F = fp128::Field; const D: usize = 64; -type Cfg = fp128::D64OneHot; +type Cfg = fp128::OneHot; 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; diff --git a/profile/akita-recursion/glue/src/lib.rs b/profile/akita-recursion/glue/src/lib.rs index 003b64296..2e59c0749 100644 --- a/profile/akita-recursion/glue/src/lib.rs +++ b/profile/akita-recursion/glue/src/lib.rs @@ -75,7 +75,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, } diff --git a/profile/akita-recursion/guest/src/lib.rs b/profile/akita-recursion/guest/src/lib.rs index f363b7848..26420a0b7 100644 --- a/profile/akita-recursion/guest/src/lib.rs +++ b/profile/akita-recursion/guest/src/lib.rs @@ -30,7 +30,7 @@ use jolt::{end_cycle_tracking, start_cycle_tracking}; type F = fp128::Field; const D: usize = 64; -type Cfg = fp128::D64OneHot; +type Cfg = fp128::OneHot; fn verification_status(result: Result<(), AkitaError>) -> u32 { match result { @@ -40,9 +40,9 @@ 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); + // The guest ring dimension is pinned by the recursion benchmark shape, not + // `Cfg::D` (the adaptive preset's envelope dimension). + assert!(D == 64); }; // Memory limits sized for the Akita verifier with `D=64 OneHot`. Blob size diff --git a/profile/akita-recursion/host/src/main.rs b/profile/akita-recursion/host/src/main.rs index 32471c093..257dd4991 100644 --- a/profile/akita-recursion/host/src/main.rs +++ b/profile/akita-recursion/host/src/main.rs @@ -30,7 +30,7 @@ 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; +type Cfg = fp128::OneHot; const _: () = { assert!(D == ::D); diff --git a/scripts/tests/test_profile_bench_report.py b/scripts/tests/test_profile_bench_report.py index e8f9eb2e0..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, @@ -513,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", @@ -570,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, }, @@ -593,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 = { From 11e07d04a9b670a30e8826c299367dfb26002029 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Fri, 7 Aug 2026 14:13:31 -0700 Subject: [PATCH 21/24] fix(config): complete adaptive fp128 preset migration --- book/src/usage/feature-flags.md | 2 +- book/src/usage/jolt-recursion.md | 9 +-- crates/akita-config/src/setup_prefix_slots.rs | 2 +- crates/akita-config/tests/runtime_fallback.rs | 16 ++++- .../akita-planner/src/test/schedule_params.rs | 9 ++- profile/akita-recursion/README.md | 58 ++++++++++--------- profile/akita-recursion/artifact/src/main.rs | 22 +++---- profile/akita-recursion/glue/src/lib.rs | 13 +++-- profile/akita-recursion/guest/Cargo.toml | 4 +- profile/akita-recursion/guest/src/lib.rs | 12 +--- profile/akita-recursion/host/Cargo.toml | 4 +- profile/akita-recursion/host/src/main.rs | 6 +- 12 files changed, 86 insertions(+), 71 deletions(-) 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 3d9b32e13..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::OneHot`**; -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/crates/akita-config/src/setup_prefix_slots.rs b/crates/akita-config/src/setup_prefix_slots.rs index 1cdb7ac77..f1b8a4373 100644 --- a/crates/akita-config/src/setup_prefix_slots.rs +++ b/crates/akita-config/src/setup_prefix_slots.rs @@ -266,7 +266,7 @@ mod tests { .expect("slot ids"); assert!(!ids.is_empty()); for slot_id in &ids { - assert_eq!(slot_id.d_setup(), 64); + assert_eq!(slot_id.d_setup(), 256); assert!(slot_id.natural_len > 0); assert!(slot_id.n_prefix().expect("n_prefix") >= slot_id.natural_len); } diff --git a/crates/akita-config/tests/runtime_fallback.rs b/crates/akita-config/tests/runtime_fallback.rs index a4d7109a5..fdd9cf21a 100644 --- a/crates/akita-config/tests/runtime_fallback.rs +++ b/crates/akita-config/tests/runtime_fallback.rs @@ -289,8 +289,20 @@ fn resolved_row_audit_rejects_each_noncanonical_terminal_shape_field() { } #[test] -fn removed_scalar_catalog_rejects_through_recursive_adapter_without_recursive_feature() { - let key = AkitaScheduleLookupKey::single(PolynomialGroupLayout::singleton(18)); +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(_)) diff --git a/crates/akita-planner/src/test/schedule_params.rs b/crates/akita-planner/src/test/schedule_params.rs index 3080c0b5d..d0d9e5243 100644 --- a/crates/akita-planner/src/test/schedule_params.rs +++ b/crates/akita-planner/src/test/schedule_params.rs @@ -527,8 +527,7 @@ fn adaptive_nv36_minimizes_setup_before_proof_bytes() { .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), @@ -841,9 +840,9 @@ fn recursive_exact_cutover_proof_size_is_documented() { ) .unwrap(); - assert!( - planned.estimate.estimated_proof_payload_bytes().unwrap() > 0, - "recursive adaptive catalog must produce a finite proof-size estimate" + assert_eq!( + planned.estimate.estimated_proof_payload_bytes().unwrap(), + 96_984 ); } 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 1cb7569dc..747929f19 100644 --- a/profile/akita-recursion/artifact/src/main.rs +++ b/profile/akita-recursion/artifact/src/main.rs @@ -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. The default recursion blob -//! pins ring dimension `D=64` for the benchmark shape. +//! 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,8 +49,8 @@ use tracing_subscriber::EnvFilter; struct Args {} type F = fp128::Field; -const D: usize = 64; 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; @@ -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 2e59c0749..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. @@ -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 26420a0b7..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::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 _: () = { - // The guest ring dimension is pinned by the recursion benchmark shape, not - // `Cfg::D` (the adaptive preset's envelope dimension). - assert!(D == 64); -}; - -// 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 257dd4991..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::OneHot; - -const _: () = { - assert!(D == ::D); -}; +const D: usize = ::D; #[derive(Debug, Parser)] #[command( From c793937a9f3282da69a68273045dc7e799af6db7 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Fri, 7 Aug 2026 16:40:58 -0700 Subject: [PATCH 22/24] refactor(planner): use uniform standalone precommits --- crates/akita-config/src/lib.rs | 16 ++-- .../src/precommitted_commitment.rs | 7 +- crates/akita-config/src/proof_optimized.rs | 26 +++++ .../akita-config/src/proof_optimized/tests.rs | 18 ++++ crates/akita-config/src/setup_prefix_slots.rs | 6 +- .../akita-pcs/src/scheme/tests/dense_group.rs | 96 +++---------------- .../examples/mixed_dimension_search.rs | 17 +--- crates/akita-planner/src/schedule_params.rs | 48 ++++------ .../akita-planner/src/test/schedule_params.rs | 56 ++++------- .../fp128_dense_multi_chunk_precommitted.rs | 7 +- .../src/generated/fp128_dense_precommitted.rs | 12 +-- .../src/generated/fp128_onehot.rs | 66 ++++++------- .../src/generated/fp128_onehot_multi_chunk.rs | 14 +-- .../fp128_onehot_multi_chunk_precommitted.rs | 8 +- .../fp128_onehot_multi_chunk_w2r2.rs | 11 +-- ...28_onehot_multi_chunk_w2r2_precommitted.rs | 12 +-- ...28_onehot_multi_chunk_w4r2_precommitted.rs | 12 +-- .../generated/fp128_onehot_precommitted.rs | 14 +-- .../src/generated/fp128_onehot_recursive.rs | 25 ++--- ...fp128_onehot_recursive_multi_chunk_w8r2.rs | 16 ++-- ...recursive_multi_chunk_w8r2_precommitted.rs | 8 +- .../fp128_onehot_recursive_precommitted.rs | 14 +-- specs/mixed-ring-dimension-per-level.md | 9 +- specs/modular-planner-and-precommit-roles.md | 22 ++--- 24 files changed, 248 insertions(+), 292 deletions(-) diff --git a/crates/akita-config/src/lib.rs b/crates/akita-config/src/lib.rs index e4ca5ca9f..83fe7bf72 100644 --- a/crates/akita-config/src/lib.rs +++ b/crates/akita-config/src/lib.rs @@ -746,14 +746,16 @@ mod precommit_tests { ) .expect("precommitted group params"); let precommitted = akita_types::CommittedGroupProfile::from_params(group, ¶ms); - let scalar_schedule = - fp128::OneHot::runtime_schedule(AkitaScheduleLookupKey::single(group)) - .expect("generated scalar schedule"); - let scalar_root = akita_types::CommittedGroupProfile::from_params( - group, - &scalar_schedule.root.params.final_group.commitment, + 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" ); - assert_eq!(precommitted, scalar_root); let root_basis = fp128::OneHot::basis_range().0; assert_eq!(precommitted.log_basis_inner, root_basis); assert_eq!(precommitted.log_basis_outer, root_basis); diff --git a/crates/akita-config/src/precommitted_commitment.rs b/crates/akita-config/src/precommitted_commitment.rs index 4de3319bc..8fd3161f3 100644 --- a/crates/akita-config/src/precommitted_commitment.rs +++ b/crates/akita-config/src/precommitted_commitment.rs @@ -3,8 +3,9 @@ //! 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; @@ -196,6 +197,8 @@ mod tests { fn dense_precommit_profile_uses_dense_config() { let key = PolynomialGroupLayout::new(15, 2); 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 0e5aefd67..9338f3542 100644 --- a/crates/akita-config/src/proof_optimized.rs +++ b/crates/akita-config/src/proof_optimized.rs @@ -140,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; diff --git a/crates/akita-config/src/proof_optimized/tests.rs b/crates/akita-config/src/proof_optimized/tests.rs index 47898642b..feaebfdd7 100644 --- a/crates/akita-config/src/proof_optimized/tests.rs +++ b/crates/akita-config/src/proof_optimized/tests.rs @@ -145,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/setup_prefix_slots.rs b/crates/akita-config/src/setup_prefix_slots.rs index f1b8a4373..30ec48c44 100644 --- a/crates/akita-config/src/setup_prefix_slots.rs +++ b/crates/akita-config/src/setup_prefix_slots.rs @@ -266,10 +266,14 @@ mod tests { .expect("slot ids"); assert!(!ids.is_empty()); for slot_id in &ids { - assert_eq!(slot_id.d_setup(), 256); 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-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-planner/examples/mixed_dimension_search.rs b/crates/akita-planner/examples/mixed_dimension_search.rs index a651464fd..46c065c5b 100644 --- a/crates/akita-planner/examples/mixed_dimension_search.rs +++ b/crates/akita-planner/examples/mixed_dimension_search.rs @@ -1,8 +1,8 @@ use akita_config::{ 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; @@ -104,19 +104,12 @@ fn main() -> Result<(), akita_field::AkitaError> { 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, + let descriptor = derive_standalone_precommit_profile( + precommit_layout, + &direct_policy, OneHot::root_honest_fold_policy(), - &[], - &precommit_policy, OneHot::ring_challenge_config, )?; - let descriptor = CommittedGroupProfile::from_params( - precommit_layout, - &precommit.schedule.root.params.final_group.commitment, - ); let recursive_key = AkitaScheduleLookupKey { final_group: PolynomialGroupLayout::new(32, 2), precommitteds: vec![descriptor, descriptor], diff --git a/crates/akita-planner/src/schedule_params.rs b/crates/akita-planner/src/schedule_params.rs index b0901ecab..85366267b 100644 --- a/crates/akita-planner/src/schedule_params.rs +++ b/crates/akita-planner/src/schedule_params.rs @@ -239,11 +239,9 @@ pub(crate) fn layout_candidate_score( /// Offline canonical standalone precommit descriptor for one group. /// -/// For adaptive policies, the profile is the A/B geometry of the canonical -/// scalar schedule's final root group. This keeps `commit_group` and a later -/// scalar opening on the same generated row when global planning selects -/// different dimensions from a locally minimized commitment. Uniform policies -/// retain their direct, group-local minimization for specialized catalogs. +/// 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, @@ -252,24 +250,21 @@ pub fn derive_standalone_precommit_profile( ) -> Result { key.validate()?; let schedule_key = AkitaScheduleLookupKey::single(key); - if matches!( - policy.ring_dimension_schedule_mode, - crate::RingDimensionScheduleMode::AdaptiveDimension { .. } - ) { - let planned = crate::planner::find_schedule( - &schedule_key, - honest_fold_policy, - &[], - policy, - ring_challenge_config, - )?; - return Ok(CommittedGroupProfile::from_params( - key, - &planned.schedule.root.params.final_group.commitment, - )); - } - 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); akita_schedules::planner_support::validate_policy(&direct_policy)?; let witness_len = 1usize @@ -277,16 +272,11 @@ pub fn derive_standalone_precommit_profile( .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 crate::RingDimensionScheduleMode::UniformDimension { ring_dimension } = - direct_policy.ring_dimension_schedule_mode - else { - unreachable!("adaptive precommit planning returns above"); - }; for candidate_log_basis in min_log_basis..=max_log_basis { let dimensions = akita_schedules::planner_support::RingDimensionCandidate::Fixed( - CommitmentRingDims::uniform(ring_dimension), + CommitmentRingDims::uniform(precommit_dimension), ); - let ring_challenge_cfg = ring_challenge_config(ring_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, diff --git a/crates/akita-planner/src/test/schedule_params.rs b/crates/akita-planner/src/test/schedule_params.rs index d0d9e5243..436d6854b 100644 --- a/crates/akita-planner/src/test/schedule_params.rs +++ b/crates/akita-planner/src/test/schedule_params.rs @@ -702,8 +702,8 @@ fn adaptive_root_domain_is_independent_of_uniform_config_dimension() { CommitmentRingDims::uniform(64), CommitmentRingDims { inner: 256, - outer: 128, - opening: 128, + outer: 64, + opening: 64, }, ]) .expect("supported fp128 adaptive domain"); @@ -801,29 +801,19 @@ fn recursive_exact_cutover_proof_size_is_documented() { use akita_config::{ policy_of, proof_optimized::fp128::OneHot, CommitmentConfig, RecursiveCommitmentConfig, }; - use akita_types::{AkitaScheduleLookupKey, CommittedGroupProfile}; + use akita_types::AkitaScheduleLookupKey; type Recursive = RecursiveCommitmentConfig; let precommit_layout = PolynomialGroupLayout::singleton(16); - let precommit_policy = policy_of::(); - let precommit_domain = RingDimensionSearchDomain::new([ - CommitmentRingDims::uniform(64), - CommitmentRingDims::uniform(128), - CommitmentRingDims::uniform(256), - ]) - .unwrap(); - let precommit = find_schedule( + let descriptor = derive_standalone_precommit_profile( precommit_layout, - &precommit_policy, + &policy_of::(), OneHot::root_honest_fold_policy(), - &precommit_domain, 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], @@ -842,7 +832,7 @@ fn recursive_exact_cutover_proof_size_is_documented() { assert_eq!( planned.estimate.estimated_proof_payload_bytes().unwrap(), - 96_984 + 96_876 ); } @@ -852,28 +842,18 @@ 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, CommittedGroupProfile}; + use akita_types::AkitaScheduleLookupKey; let precommit_layout = PolynomialGroupLayout::singleton(16); - let precommit_policy = policy_of::(); - let precommit_domain = RingDimensionSearchDomain::new([ - CommitmentRingDims::uniform(64), - CommitmentRingDims::uniform(128), - CommitmentRingDims::uniform(256), - ]) - .unwrap(); - let precommit = find_schedule( + let descriptor = derive_standalone_precommit_profile( precommit_layout, - &precommit_policy, + &policy_of::(), OneHot::root_honest_fold_policy(), - &precommit_domain, 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], @@ -902,8 +882,8 @@ fn recursive_adaptive_search_selects_schedule_dimensions_and_setup_prefixes() { .role_dims(), CommitmentRingDims { inner: 256, - outer: 128, - opening: 128, + outer: 64, + opening: 64, } ); assert_eq!( @@ -915,7 +895,7 @@ fn recursive_adaptive_search_selects_schedule_dimensions_and_setup_prefixes() { .commitment .open_commit_matrix .input_width(), - 88_408, + 176_472, "root D width projects the main group once and then adds both frozen precommit segments" ); assert_eq!( @@ -925,8 +905,8 @@ fn recursive_adaptive_search_selects_schedule_dimensions_and_setup_prefixes() { .role_dims(), CommitmentRingDims { inner: 256, - outer: 128, - opening: 128, + outer: 64, + opening: 64, } ); assert_eq!( diff --git a/crates/akita-schedules/src/generated/fp128_dense_multi_chunk_precommitted.rs b/crates/akita-schedules/src/generated/fp128_dense_multi_chunk_precommitted.rs index e0fb9229e..43f5994a7 100644 --- a/crates/akita-schedules/src/generated/fp128_dense_multi_chunk_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_dense_multi_chunk_precommitted.rs @@ -6,5 +6,10 @@ use super::{ #[rustfmt::skip] pub(crate) static FP128_DENSE_MULTI_CHUNK_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 16, 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: 5, inner_coeff_linf_bound: 1048575, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, + 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 }, + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), 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 }, + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 8, live_blocks: 128 }, 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(16, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 16, 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: 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_dense_precommitted.rs b/crates/akita-schedules/src/generated/fp128_dense_precommitted.rs index a8e618e40..1d8c4999c 100644 --- a/crates/akita-schedules/src/generated/fp128_dense_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_dense_precommitted.rs @@ -6,10 +6,10 @@ use super::{ #[rustfmt::skip] pub(crate) static FP128_DENSE_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 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 } }, num_digits_inner: 43, inner_output_rank: 1, inner_coeff_linf_bound: 65535, 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: 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 } }, num_digits_inner: 43, inner_output_rank: 1, inner_coeff_linf_bound: 65535, 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: 8, 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 } }, num_digits_inner: 43, inner_output_rank: 1, inner_coeff_linf_bound: 65535, 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: 16, 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 } }, num_digits_inner: 43, inner_output_rank: 1, inner_coeff_linf_bound: 65535, 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: 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 } }, num_digits_inner: 43, inner_output_rank: 1, inner_coeff_linf_bound: 65535, 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: 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 } }, num_digits_inner: 43, inner_output_rank: 1, inner_coeff_linf_bound: 65535, num_digits_outer: 43, outer_output_rank: 1, outer_coeff_linf_bound: 7 }, + 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 }, + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), 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 }, + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), 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 } }, 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(16, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 1024, positions_per_block: 64, 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_onehot.rs b/crates/akita-schedules/src/generated/fp128_onehot.rs index a45cd3419..4abc777dc 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot.rs @@ -84,15 +84,15 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ 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: 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(15, 2), num_live_ring_elements_per_claim: 128, num_positions_per_block: 16, num_live_blocks: 8, log_basis_inner: 3, num_digits_inner: 43, 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, 1, 688, 65535, 256), 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, 2752, 7, 64) }, num_digits_fold: 3, commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 16, 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 } } }, + 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(15, 2), num_live_ring_elements_per_claim: 512, num_positions_per_block: 32, num_live_blocks: 16, log_basis_inner: 3, num_digits_inner: 43, 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, 5, 1376, 1048575, 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, 6880, 7, 64) }, 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: 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::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 22569, 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::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 21407, 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 }, ], @@ -147,15 +147,15 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 2), num_live_ring_elements_per_claim: 128, num_positions_per_block: 64, 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, 64, 16383, 128), 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: 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: 64, log_basis: 3, slice_count: 1 } } }, + GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 2), 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, 3, 128, 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: 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::Single, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 7176, 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: 6746, 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 }, }, @@ -176,18 +176,18 @@ pub(crate) static FP128_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 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 2), num_digits_inner: 1, num_digits_fold: 3, + 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, + 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, ], 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: 9526, positions_per_block: 1024, live_blocks: 10 }, 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: 5592, 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: 11597, 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::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 }, @@ -210,17 +210,17 @@ pub(crate) static FP128_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 } } }, + final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 4), num_digits_inner: 1, num_digits_fold: 3, + 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, + 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, + 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, ], 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: 15689, 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: 15660, 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 }, @@ -229,21 +229,21 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ }, GeneratedFoldScheduleEntry { root: GeneratedRootFold { - final_group: GeneratedRootFinalGroup { layout: PolynomialGroupLayout::new(20, 4), num_digits_inner: 1, num_digits_fold: 3, - 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 } } }, + 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(14, 1), num_live_ring_elements_per_claim: 64, num_positions_per_block: 16, 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, 1, 16, 8191, 256), 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: 2, 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 } } }, + 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, + 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, + 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, 3, 128, 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, 258, 7, 64) }, num_digits_fold: 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 } } }, ], 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: 19879, 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 }, + GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 14528, 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 }, ], 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 }, }, @@ -339,15 +339,15 @@ pub(crate) static FP128_ONEHOT_SCHEDULES: &[GeneratedFoldScheduleEntry] = &[ 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 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, 1, 128, 1023, 256), 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, 344, 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: 256, 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: 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, 1, 128, 1023, 256), 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, 344, 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: 256, 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 } } }, + 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 } } }, ], 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: 794751, positions_per_block: 8192, live_blocks: 98 }, 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: 58749, positions_per_block: 2048, live_blocks: 29 }, 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: 794407, positions_per_block: 8192, live_blocks: 97 }, 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: 58491, positions_per_block: 2048, live_blocks: 29 }, 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: 16371, 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 }, @@ -481,5 +481,5 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 3458533356553718245, key_count: 26, - key_digest: 8976661807121841406, + key_digest: 17058955708590941206, }; diff --git a/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk.rs index becafa8b4..b59cdbaec 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk.rs @@ -37,17 +37,17 @@ pub(crate) static FP128_ONEHOT_MULTI_CHUNK_SCHEDULES: &[GeneratedFoldScheduleEnt 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: 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 } } }, precommitted_groups: &[ - GeneratedRootPrecommittedGroup { descriptor: CommittedGroupProfile { version: CommittedGroupProfile::VERSION, group: PolynomialGroupLayout::new(16, 1), num_live_ring_elements_per_claim: 256, num_positions_per_block: 4, num_live_blocks: 64, 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, 1, 4, 8191, 256), 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, 11008, 7, 64) }, 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: 256, 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: 256, num_positions_per_block: 4, num_live_blocks: 64, 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, 1, 4, 8191, 256), 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, 11008, 7, 64) }, 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: 256, 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 } } }, + 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 } } }, ], 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: 1713567, positions_per_block: 4096, live_blocks: 419 }, 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: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, 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: 225560, positions_per_block: 4096, live_blocks: 56 }, 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: 23640, 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: 1672705, positions_per_block: 4096, live_blocks: 409 }, 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: 4, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 64, log_basis: 4, 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: 223320, 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 }, ], @@ -87,5 +87,5 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 3458533356553718245, key_count: 2, - key_digest: 7378248310254082085, + key_digest: 3783944043367586616, }; diff --git a/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_precommitted.rs index 9757cb2c8..b7a640532 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_precommitted.rs @@ -6,6 +6,10 @@ use super::{ #[rustfmt::skip] pub(crate) static FP128_ONEHOT_MULTI_CHUNK_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 4, 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 } }, 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, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 8, live_blocks: 32 }, 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_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(14, 1), 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: 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: 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: 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: 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 } }, 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(15, 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 } }, 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: 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 } }, 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(16, 2), 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 } }, 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_onehot_multi_chunk_w2r2.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2.rs index 50a342961..052d23038 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2.rs @@ -33,16 +33,15 @@ pub(crate) static FP128_ONEHOT_MULTI_CHUNK_W2R2_SCHEDULES: &[GeneratedFoldSchedu 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: 64, num_positions_per_block: 8, 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, 1, 8, 8191, 256), 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, 1376, 7, 64) }, 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: 64, log_basis: 3, slice_count: 1 } } }, + 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: 6139, 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::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: 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 }, }, @@ -98,5 +97,5 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 3458533356553718245, key_count: 3, - key_digest: 12169120462852202984, + key_digest: 690501068951054480, }; diff --git a/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2_precommitted.rs index c1e696265..20165b946 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w2r2_precommitted.rs @@ -6,10 +6,10 @@ use super::{ #[rustfmt::skip] 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: 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 } }, 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(14, 2), 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 } }, 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: 16, 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 } }, 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, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 32, 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 } }, 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: 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 } }, 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, 2), 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 } }, 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, 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 }, + 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: 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: 2, inner_coeff_linf_bound: 2047, 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: 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 }, ]; diff --git a/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2_precommitted.rs index 05f7f1d7c..6eedfddd7 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_multi_chunk_w4r2_precommitted.rs @@ -6,10 +6,10 @@ use super::{ #[rustfmt::skip] 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: 64, positions_per_block: 4, 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 } }, 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(14, 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: 64, 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: 8, 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 } }, 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, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 128, positions_per_block: 16, 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 } }, 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: 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 } }, 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, 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: 64, 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(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 }, + GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(15, 2), 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: 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: 2, inner_coeff_linf_bound: 2047, 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: 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 }, ]; diff --git a/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs index 3bdc4c532..713adebb2 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_precommitted.rs @@ -6,11 +6,11 @@ use super::{ #[rustfmt::skip] pub(crate) static FP128_ONEHOT_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(14, 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 } }, 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(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: 64, 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: 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 } }, 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, 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: 64, 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: 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 } }, 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: 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(20, 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 } }, 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(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/fp128_onehot_recursive.rs b/crates/akita-schedules/src/generated/fp128_onehot_recursive.rs index 20fd6a925..2b21e0f62 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot_recursive.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_recursive.rs @@ -16,21 +16,22 @@ 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: 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 } } }, + 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: 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, 1, 128, 1023, 256), 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, 344, 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: 256, 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: 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, 1, 128, 1023, 256), 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, 344, 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: 256, 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 } } }, + 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 } } }, ], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 3, slice_count: 1 }, + 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: 187531, positions_per_block: 1024, live_blocks: 184 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } }, num_digits_fold: 3, open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, log_basis: 6, 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: 256, live_blocks: 256 }, inner_commit_matrix: GeneratedInnerCommitMatrix { ring_dimension: 256, log_basis: 6 }, outer_commit_matrix: GeneratedOuterCommitMatrix { ring_dimension: 128, log_basis: 6, slice_count: 1 } } }), witness_partition: GeneratedWitnessPartition::Single }, - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 197582, positions_per_block: 4096, live_blocks: 49 }, 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: 21619, positions_per_block: 1024, live_blocks: 22 }, 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: 7501, 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 }, }, @@ -43,7 +44,7 @@ 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]; +pub(crate) static CATALOG_RING_DIMENSIONS: &[usize] = &[64, 256]; #[rustfmt::skip] pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = GeneratedScheduleCatalogIdentity { family_name: "fp128_onehot_recursive", @@ -68,5 +69,5 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 3458533356553718245, key_count: 1, - key_digest: 12496825170785853240, + key_digest: 18380497388496919726, }; diff --git a/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2.rs b/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2.rs index 82c29b720..c07c8f3f5 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2.rs @@ -18,17 +18,17 @@ pub(crate) static FP128_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES: &[Generated 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: 256, num_positions_per_block: 4, num_live_blocks: 64, 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, 1, 4, 8191, 256), 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, 11008, 7, 64) }, 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: 256, 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: 256, num_positions_per_block: 4, num_live_blocks: 64, 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, 1, 4, 8191, 256), 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, 11008, 7, 64) }, 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: 256, 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 } } }, + 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 } } }, ], - open_commit_matrix: GeneratedOpenCommitMatrix { ring_dimension: 128, 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: 8 }, }, recursive_folds: &[ - GeneratedRecursiveFold { payload_mode: CommitmentPayloadMode::Compressed, witness: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 624051, positions_per_block: 1024, live_blocks: 610 }, 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: 128, log_basis: 5, slice_count: 1 }, incoming_setup_prefix: Some(GeneratedSetupPrefixInput { natural_len: 12681216, 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: 769530, positions_per_block: 8192, live_blocks: 94 }, 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: 8120320, 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: 121341, positions_per_block: 2048, live_blocks: 60 }, 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: 17411, 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: 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 }, @@ -69,5 +69,5 @@ pub(crate) static CATALOG_IDENTITY: GeneratedScheduleCatalogIdentity = Generated ring_dimensions: CATALOG_RING_DIMENSIONS, ring_challenge_config_digest: 3458533356553718245, key_count: 1, - key_digest: 6382696790429857975, + key_digest: 8477849330456216878, }; diff --git a/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2_precommitted.rs index 9458fd2d1..fa0610e4a 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_recursive_multi_chunk_w8r2_precommitted.rs @@ -6,6 +6,10 @@ use super::{ #[rustfmt::skip] pub(crate) static FP128_ONEHOT_RECURSIVE_MULTI_CHUNK_W8R2_SCHEDULES_PRECOMMITTED_PROFILES: &[GeneratedPrecommittedProfile] = &[ - GeneratedPrecommittedProfile { group: PolynomialGroupLayout::new(16, 1), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 4, 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 } }, 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, 2), commitment: GeneratedCommittedGroup { geometry: GeneratedBlockGeometry { live_ring_elements_per_claim: 256, positions_per_block: 8, live_blocks: 32 }, 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_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(14, 1), 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: 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: 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: 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: 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 } }, 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(15, 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 } }, 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: 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 } }, 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(16, 2), 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 } }, 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_onehot_recursive_precommitted.rs b/crates/akita-schedules/src/generated/fp128_onehot_recursive_precommitted.rs index 6ea88cc55..f6f5e4c9f 100644 --- a/crates/akita-schedules/src/generated/fp128_onehot_recursive_precommitted.rs +++ b/crates/akita-schedules/src/generated/fp128_onehot_recursive_precommitted.rs @@ -6,11 +6,11 @@ use super::{ #[rustfmt::skip] 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: 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 } }, 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(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: 64, 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: 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 } }, 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, 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: 64, 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: 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 } }, 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: 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(20, 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 } }, 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(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/specs/mixed-ring-dimension-per-level.md b/specs/mixed-ring-dimension-per-level.md index d390d2496..8b6f640cc 100644 --- a/specs/mixed-ring-dimension-per-level.md +++ b/specs/mixed-ring-dimension-per-level.md @@ -77,8 +77,8 @@ precommitted groups. The selected schedules are: ```text single chunk: - root 256/128/128 - L1 256/128/128 (consumes setup prefix committed at 256/128) + root 256/64/64 + L1 256/64/64 (consumes setup prefix committed at 256/64) L2+ 64/64/64 W8R2: @@ -88,8 +88,9 @@ W8R2: L3+ 64/64/64 ``` -The frozen precommit descriptors remain part of the root lookup key. The -single-chunk precommits use A/B `256/64`; W8R2 precommits use `64/64`. At every +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. diff --git a/specs/modular-planner-and-precommit-roles.md b/specs/modular-planner-and-precommit-roles.md index f5a40df1d..4d21a9758 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 @@ -553,9 +551,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. From 9f9cab143dab4470177e9752c798b997da72c5be Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Fri, 7 Aug 2026 17:28:28 -0700 Subject: [PATCH 23/24] fix adaptive benchmark ring dimensions --- crates/akita-pcs/benches/akita_e2e.rs | 14 ++++++++------ crates/akita-pcs/examples/profile/workload.rs | 8 ++++---- crates/akita-prover/src/compute/cpu.rs | 10 +++++----- 3 files changed, 17 insertions(+), 15 deletions(-) diff --git a/crates/akita-pcs/benches/akita_e2e.rs b/crates/akita-pcs/benches/akita_e2e.rs index 3cdf34656..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]; @@ -429,13 +431,13 @@ fn bench_dense_nv24(c: &mut Criterion) { } fn bench_onehot_nv15(c: &mut Criterion) { - bench_onehot_phases::<{ fp128::OneHot::D }, fp128::OneHot>(c, "onehot-adaptive", 15); + bench_onehot_phases::(c, "onehot-adaptive", 15); } fn bench_onehot_nv20(c: &mut Criterion) { - bench_onehot_phases::<{ fp128::OneHot::D }, fp128::OneHot>(c, "onehot-adaptive", 20); + bench_onehot_phases::(c, "onehot-adaptive", 20); } fn bench_onehot_nv25(c: &mut Criterion) { - bench_onehot_phases::<{ fp128::OneHot::D }, fp128::OneHot>(c, "onehot-adaptive", 25); + bench_onehot_phases::(c, "onehot-adaptive", 25); } criterion_group!( diff --git a/crates/akita-pcs/examples/profile/workload.rs b/crates/akita-pcs/examples/profile/workload.rs index e0b7c30bf..3a1c0876e 100644 --- a/crates/akita-pcs/examples/profile/workload.rs +++ b/crates/akita-pcs/examples/profile/workload.rs @@ -781,7 +781,7 @@ pub(crate) fn run_dense_for() + .shared_ntt_profile(layout.d_a()) .expect("prepared setup CRT profile"), ); run_prove::>( @@ -859,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::>( @@ -952,7 +952,7 @@ pub(crate) fn run_batched_onehot() + .shared_ntt_profile(layout.d_a()) .expect("prepared setup CRT profile"), ); let t0 = Instant::now(); @@ -1255,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-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); From 149cfac754cfb213cbf0c40b44be34276b598ed1 Mon Sep 17 00:00:00 2001 From: Omid Bodaghi <42227752+omibo@users.noreply.github.com> Date: Fri, 7 Aug 2026 19:43:21 -0700 Subject: [PATCH 24/24] refactor(planner): unify adaptive suffix search --- crates/akita-planner/src/planner.rs | 44 +- crates/akita-planner/src/schedule_params.rs | 44 +- .../src/schedule_params/mixed_search.rs | 434 ------------------ .../src/schedule_params/suffix_dp.rs | 129 ++++-- crates/akita-planner/src/test/mixed_search.rs | 47 -- .../akita-planner/src/test/schedule_params.rs | 63 +-- crates/akita-planner/src/test/suffix_dp.rs | 49 +- .../akita-planner/src/test/unpruned_search.rs | 4 +- 8 files changed, 226 insertions(+), 588 deletions(-) delete mode 100644 crates/akita-planner/src/schedule_params/mixed_search.rs delete mode 100644 crates/akita-planner/src/test/mixed_search.rs diff --git a/crates/akita-planner/src/planner.rs b/crates/akita-planner/src/planner.rs index 39c2041d4..390be2c80 100644 --- a/crates/akita-planner/src/planner.rs +++ b/crates/akita-planner/src/planner.rs @@ -17,8 +17,8 @@ use akita_types::{ 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, RingChallengeConfigFn, ScheduleMemo, SuffixCtx, SuffixState, + derive_optimal_suffix_schedule, materialize_candidate_schedule, select_complete_candidate, + RingChallengeConfigFn, ScheduleMemo, SuffixCtx, SuffixState, }; use crate::PlannerPolicy; @@ -554,15 +554,9 @@ pub fn find_schedule( ) { if key.precommitteds.is_empty() { validate_adaptive_dimension_schedule_request(key, policy)?; - return mixed_search::find_schedule( - key.final_group, - policy, - final_honest_fold_policy, - ring_challenge_config, - ); } - if !policy.recursive_setup_planning { + 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. @@ -629,6 +623,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, @@ -637,7 +645,7 @@ pub fn find_schedule( current_witness_len: root_input_witness_len, current_lb: 0, incoming_setup_prefix: None, - dimension_ceiling: CommitmentRingDims::uniform(active_policy.uniform_ring_dimension), + dimension_ceiling, payload_phase: akita_types::CommitmentPayloadPhase::CompressedPrefix, }, 0, @@ -647,9 +655,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, @@ -658,6 +664,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 85366267b..03d477a43 100644 --- a/crates/akita-planner/src/schedule_params.rs +++ b/crates/akita-planner/src/schedule_params.rs @@ -15,17 +15,19 @@ use akita_types::sis::{ FoldWitnessNorms, HonestFoldPolicy, HonestFoldPolicySpec, HonestFoldSizingQuery, InnerCommitMatrixParams, OpenCommitMatrixParams, OuterCommitMatrixParams, }; +#[cfg(test)] +use akita_types::{ + level_proof_bytes, try_extension_opening_reduction_level_bytes, PlannedFoldSchedule, +}; use akita_types::{ - level_proof_bytes, padded_setup_prefix_len, try_extension_opening_reduction_level_bytes, - AkitaScheduleLookupKey, CommitmentRingDims, CommittedGroupParams, CommittedGroupProfile, - DecompositionParams, PlannedFoldSchedule, PolynomialGroupLayout, PrecommittedLevelParams, + padded_setup_prefix_len, AkitaScheduleLookupKey, CommitmentRingDims, CommittedGroupParams, + CommittedGroupProfile, DecompositionParams, PolynomialGroupLayout, PrecommittedLevelParams, WitnessLayout, }; use crate::PlannerPolicy; mod candidate; -pub(crate) mod mixed_search; mod objective; mod setup_score; mod suffix_dp; @@ -46,15 +48,19 @@ pub(crate) use setup_score::{ }; pub(crate) use suffix_dp::{derive_optimal_suffix_schedule, ScheduleMemo, SuffixCtx, SuffixState}; -fn exact_dimension_candidates( +fn dimension_candidates( policy: &PlannerPolicy, level: usize, ceiling: CommitmentRingDims, -) -> Result, AkitaError> { +) -> 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![CommitmentRingDims::uniform(ring_dimension)] + vec![RingDimensionCandidate::Fixed(CommitmentRingDims::uniform( + ring_dimension, + ))] } crate::RingDimensionScheduleMode::AdaptiveDimension { num_search_levels, @@ -64,7 +70,23 @@ fn exact_dimension_candidates( potential_d_dimensions, } => { if level >= num_search_levels { - vec![CommitmentRingDims::uniform(uniform_suffix_dimension)] + 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 { @@ -79,11 +101,11 @@ fn exact_dimension_candidates( if opening > ceiling.d_d() || !inner.is_multiple_of(opening) { continue; } - candidates.push(CommitmentRingDims { + candidates.push(RingDimensionCandidate::Fixed(CommitmentRingDims { inner, outer, opening, - }); + })); } } } @@ -95,7 +117,7 @@ fn exact_dimension_candidates( } #[cfg(test)] -pub(crate) const MIXED_SEARCH_SUFFIX_RING_DIMENSION: usize = 64; +pub(crate) const ADAPTIVE_SUFFIX_RING_DIMENSION: usize = 64; /// Explicit A/B/D dimensions admitted by mixed-D planner search. /// 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 597a085d5..000000000 --- a/crates/akita-planner/src/schedule_params/mixed_search.rs +++ /dev/null @@ -1,434 +0,0 @@ -use std::collections::HashMap; - -use super::*; -use akita_schedules::planner_support::MAX_RECURSION_DEPTH; - -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, - 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 { - let crate::RingDimensionScheduleMode::AdaptiveDimension { - num_search_levels, - uniform_suffix_dimension, - potential_a_dimensions, - potential_b_dimensions, - potential_d_dimensions, - } = policy.ring_dimension_schedule_mode - else { - return Err(AkitaError::InvalidSetup( - "adaptive search requires adaptive mode".into(), - )); - }; - let candidate_dimensions = if level >= num_search_levels { - vec![ - akita_schedules::planner_support::RingDimensionCandidate::Fixed( - CommitmentRingDims::uniform(uniform_suffix_dimension), - ), - ] - } else { - potential_a_dimensions - .iter() - .copied() - .filter(|&inner| inner <= dimension_ceiling.d_a()) - .map( - |inner| akita_schedules::planner_support::RingDimensionCandidate::Adaptive { - inner, - outer_dimensions: potential_b_dimensions, - opening_dimensions: potential_d_dimensions, - ceiling: dimension_ceiling, - }, - ) - .collect() - }; - for candidate_dimensions in candidate_dimensions { - let Some(eor_bytes) = try_extension_opening_reduction_level_bytes( - challenge_field_bits, - policy.claim_ext_degree, - level, - key, - input_witness_len, - candidate_dimensions.inner(), - )? - else { - continue; - }; - let Ok(ring_challenge) = ring_challenge_config(candidate_dimensions.inner()) else { - continue; - }; - for &payload_mode in payload_phase.candidate_modes(level, false) { - let candidates = if level < num_search_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 >= num_search_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 >= num_search_levels { - CommitmentRingDims::uniform(uniform_suffix_dimension) - } else { - params.role_dims() - }; - for child in suffix_frontier( - policy, - 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, - 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); - - let crate::RingDimensionScheduleMode::AdaptiveDimension { - num_search_levels: _, - uniform_suffix_dimension: _, - potential_a_dimensions, - potential_b_dimensions, - potential_d_dimensions, - } = policy.ring_dimension_schedule_mode - else { - return Err(AkitaError::InvalidSetup( - "adaptive search requires adaptive mode".into(), - )); - }; - for log_basis in min_log_basis..=max_log_basis { - for &root_inner in potential_a_dimensions { - let root_dimensions = - akita_schedules::planner_support::RingDimensionCandidate::Adaptive { - inner: root_inner, - outer_dimensions: potential_b_dimensions, - opening_dimensions: potential_d_dimensions, - // The root has no preceding schedule level. Its only - // projection ceiling is its own A-native source ring; the - // config's uniform-D field is unrelated to adaptive search. - ceiling: CommitmentRingDims::uniform(root_inner), - }; - let alpha = root_dimensions.inner().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.inner()) 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.inner(), - )? - else { - continue; - }; - for suffix in suffix_frontier( - policy, - &ring_challenge_config, - key, - 1, - output_witness_len, - log_basis, - root_params.role_dims(), - 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)?.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 ff708d21b..2fd0d7ec2 100644 --- a/crates/akita-planner/src/schedule_params/suffix_dp.rs +++ b/crates/akita-planner/src/schedule_params/suffix_dp.rs @@ -13,16 +13,16 @@ use akita_types::{ use crate::{planner::root_level_candidates_for_basis, PlannerPolicy}; use super::{ - derive_candidate_level_params, derive_candidate_level_params_all_splits, - exact_dimension_candidates, level_setup_field_elements, stage3_payload_bytes_for_successor, - suffix_opening_layout, terminal_setup_field_elements, CandidateFoldStep, - CandidateTerminalResponse, ScheduleCandidate, + 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 @@ -32,10 +32,56 @@ use akita_schedules::planner_support::MAX_RECURSION_DEPTH; /// - `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 @@ -333,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(), }) } @@ -409,13 +470,24 @@ fn price_level_candidate_with_children( require_child_fold: bool, 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() { @@ -444,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, @@ -452,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); } } @@ -478,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, @@ -561,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( @@ -619,27 +694,31 @@ pub(crate) fn derive_optimal_suffix_schedule( AkitaError::InvalidSetup("root batch opening layout is missing".to_string()) })?; let mut candidates = Vec::new(); - for dimensions in exact_dimension_candidates(policy, level, dimension_ceiling)? { + 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.d_a(), + dimensions.inner(), )? else { continue; }; - let ring_challenge_cfg = - if dimensions == CommitmentRingDims::uniform(policy.uniform_ring_dimension) { + 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 - } else { - let Ok(config) = ring_challenge_config(dimensions.d_a()) else { + } + _ => { + let Ok(config) = ring_challenge_config(dimensions.inner()) else { continue; }; config - }; + } + }; candidates.extend( root_level_candidates_for_basis( root_key, @@ -650,7 +729,7 @@ pub(crate) fn derive_optimal_suffix_schedule( })?, precommitted_honest_fold_policies, policy, - akita_schedules::planner_support::RingDimensionCandidate::Fixed(dimensions), + dimensions, &ring_challenge_cfg, ring_challenge_config, current_witness_len, @@ -675,19 +754,19 @@ pub(crate) fn derive_optimal_suffix_schedule( .. } if level < num_search_levels ); - for dimensions in exact_dimension_candidates(policy, level, dimension_ceiling)? { + 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.d_a(), + dimensions.inner(), )? else { continue; }; - let Ok(ring_challenge_cfg) = ring_challenge_config(dimensions.d_a()) else { + 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()) { @@ -696,9 +775,7 @@ pub(crate) fn derive_optimal_suffix_schedule( policy, mode, &ring_challenge_cfg, - akita_schedules::planner_support::RingDimensionCandidate::Fixed( - dimensions, - ), + dimensions, current_witness_len, lb, level, @@ -709,9 +786,7 @@ pub(crate) fn derive_optimal_suffix_schedule( policy, mode, &ring_challenge_cfg, - akita_schedules::planner_support::RingDimensionCandidate::Fixed( - dimensions, - ), + dimensions, current_witness_len, lb, level, @@ -801,6 +876,7 @@ pub(crate) fn derive_optimal_suffix_schedule( require_child_fold, &mut best_for_this_lb, &mut best_payload_for_this_lb, + &mut mixed_frontier, )?; } @@ -855,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 436d6854b..cbe96e7ef 100644 --- a/crates/akita-planner/src/test/schedule_params.rs +++ b/crates/akita-planner/src/test/schedule_params.rs @@ -183,65 +183,20 @@ fn mixed_domain_search_beats_or_ties_uniform_d64() { 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 + ADAPTIVE_SUFFIX_RING_DIMENSION ); } #[cfg(feature = "catalog-gen")] #[test] -fn grouped_scalar_fallback_preserves_mixed_domain() { - use akita_config::{policy_of, proof_optimized::fp128::OneHot, 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, - OneHot::root_honest_fold_policy(), - &[], - &policy, - OneHot::ring_challenge_config, - ) - .unwrap(); - let direct = mixed_search::find_schedule( - key.final_group, - &policy, - OneHot::root_honest_fold_policy(), - OneHot::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() - ); -} - -#[cfg(feature = "catalog-gen")] -#[test] -fn adaptive_mixed_search_is_canonical() { +fn adaptive_dimension_search_is_canonical() { use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; let base_policy = policy_of::(); @@ -365,7 +320,7 @@ fn adaptive_frontier_matches_unpruned_l0_l1_search() { #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_parallel_generation_is_descriptor_deterministic() { +fn adaptive_search_parallel_generation_is_descriptor_deterministic() { use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; let handles = (0..8) @@ -475,7 +430,7 @@ fn mixed_root_prices_eor_at_candidate_a_dimension() { #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_rejects_an_advertised_unsupported_role_dimension() { +fn adaptive_search_rejects_an_advertised_unsupported_role_dimension() { use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; let mut base_policy = policy_of::(); @@ -566,7 +521,7 @@ fn adaptive_nv36_minimizes_setup_before_proof_bytes() { #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_requires_a_monotonic_d64_suffix_domain() { +fn adaptive_search_requires_a_monotonic_d64_suffix_domain() { use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; let base_policy = policy_of::(); @@ -605,7 +560,7 @@ fn mixed_search_requires_a_monotonic_d64_suffix_domain() { #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_supports_direct_multi_chunk_policy() { +fn adaptive_search_supports_direct_multi_chunk_policy() { use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; let mut policy = policy_of::(); @@ -655,7 +610,7 @@ fn mixed_search_supports_direct_multi_chunk_policy() { #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_validates_key_and_policy_at_entry() { +fn adaptive_search_validates_key_and_policy_at_entry() { use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; let base_policy = policy_of::(); @@ -728,7 +683,7 @@ fn adaptive_root_domain_is_independent_of_uniform_config_dimension() { #[cfg(feature = "catalog-gen")] #[test] -fn mixed_search_applies_setup_budget_in_physical_fields() { +fn adaptive_search_applies_setup_budget_in_physical_fields() { use akita_config::{policy_of, proof_optimized::fp128::OneHot, CommitmentConfig}; let mut policy = policy_of::(); 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 2866d362c..79a1e7518 100644 --- a/crates/akita-planner/src/test/unpruned_search.rs +++ b/crates/akita-planner/src/test/unpruned_search.rs @@ -44,7 +44,7 @@ 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); + let suffix_dimensions = CommitmentRingDims::uniform(ADAPTIVE_SUFFIX_RING_DIMENSION); if level >= akita_schedules::ADAPTIVE_SEARCH_LEVELS { if *candidate_dimensions != suffix_dimensions { continue; @@ -142,7 +142,7 @@ fn enumerate_suffixes( } let child_ceiling = if level + 1 >= akita_schedules::ADAPTIVE_SEARCH_LEVELS { - CommitmentRingDims::uniform(MIXED_SEARCH_SUFFIX_RING_DIMENSION) + CommitmentRingDims::uniform(ADAPTIVE_SUFFIX_RING_DIMENSION) } else { params.role_dims() };