From 9d2399a33256e07dee97f08c39d2e20fc4f7eafa Mon Sep 17 00:00:00 2001 From: zkfriendly Date: Wed, 16 Sep 2026 21:00:05 +0200 Subject: [PATCH 1/8] readme opening --- README.md | 148 +++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 142 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index f2d0ccee..874f0c8f 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,148 @@ -# BitZ-benchmark +# BitZ -An implementation of **BitZ** — an integer-MLE-evaluation polynomial commitment -scheme over an `F_2` commitment, folded in the exponent of a binary field and -opened through a ring-switch + recursive Ligerito pipeline. +**BitZ** is a hash-based polynomial commitment scheme (PCS) for commiting to polynomials with coeffients in a ring S (e.g a finite field F, integers Z) and proves evaluation claims over another arbitrary ring R. This repo provides an implementation of a concrete instantiation of this protocol where S is the integers Z and R is a Finite Field Fq. -## Building +The repository also implements a **Spartan polynomial interactive oracle proof +(PIOP)** for end-to-end circuit proving. Spartan reduces circuit constraints to +a witness evaluation claim. BitZ proves that claim against the committed +witness. **SHA-256** is the current workload for end-to-end proving and +benchmarking. + +BitZ folds integer values, then uses GKR over `GF(2^128)`. +Ring-switching and recursive Ligerito complete the opening. +The binary commitment backend uses +[Flock](https://github.com/succinctlabs/flock). +Virtualization lets circuits derive a larger witness `h = M(1 || f)` over `F_2` +from committed bits `f`. + +This is a research implementation. Current proofs do not provide zero knowledge. + +## Build + +The workspace uses Rust **1.97.1**, pinned in `rust-toolchain.toml`. +Run these commands from the repository root: ```sh -cargo test --workspace +cargo build --release --workspace +cargo test --release --workspace +cargo fmt --all --check cargo clippy --workspace --all-targets ``` + +## SHA-256 end-to-end proving + +The SHA-256 CLI and circuit benchmarks currently require `feat/all-circuit-benches` +([PR #68](https://github.com/worldfnd/BitZ/pull/68), built on +[PR #64](https://github.com/worldfnd/BitZ/pull/64)). +These tools are not yet on `main`. + +Select that branch before running the commands below: + +```sh +git fetch origin feat/all-circuit-benches +git switch feat/all-circuit-benches +``` + +Generate random inputs, prove eight SHA-256 compression steps, and verify the proof: + +```sh +cargo run --release -p bitz-cli -- circuit-e2e \ + --circuit sha256-chain --num-blocks 8 --threads 1 +``` + +The command runs circuit setup, witness generation, commitment, proving, and +verification. The verifier uses the public statement and proof without the +witness. The SHA-256 adapters expose input bits and outputs as public values. + +`--circuit` selects one of four adapters: + +| Adapter | Workload | +| ---------------------- | --------------------------------------------------------------------------------- | +| `sha256-compression` | One raw compression block, with an optional initial state. | +| `sha256-chain` | A positive number of raw blocks from the standard initial state, without padding. | +| `sha256-block-aligned` | A block-aligned message, including an empty message, with SHA-256 padding. | +| `sha256-2kb` | A 2 KiB message with SHA-256 padding. | + +Variable-length adapters default to one input block. The 2 KiB adapter uses +32 input blocks. Use `--num-blocks` to set the length of a chain or block-aligned +message. + +The CLI reports the opening path, circuit dimensions, and timings for each +stage. `total_prove_ms` includes commitment and proving. It excludes setup, +witness generation, and verification. Input generation and thread-pool +initialization occur outside the reported timings. + +## Benchmarks + +Run the SHA-256 circuit benchmarks with one Rayon worker: + +```sh +RAYON_NUM_THREADS=1 cargo bench -p bitz-cli --bench circuits +``` + +The suite measures all four adapters across six stages: end-to-end, setup, +witness generation, commitment, proving, and verification. +The end-to-end measurement includes all five individual stages. +Chain and block-aligned benchmark cases use one input block. +Use the CLI to measure other lengths. + +Run every benchmark once to check the complete suite: + +```sh +RAYON_NUM_THREADS=1 cargo bench -p bitz-cli --bench circuits -- --test +``` + +Input generation occurs outside measurements. End-to-end and setup benchmarks +use fresh instances for each sample. Other stages reuse a prepared instance +for each benchmark case. + +Component benchmarks are also available on `main`: + +```sh +# SHA-256 witness generation and matrix operations. +cargo bench -p circuit --bench sha256_matrix_products + +# Spartan proving and verification for SHA-256 constraints. +cargo bench -p spartan --bench sha256 + +# BitZ's GKR reduction. +cargo bench -p prover --bench prover +``` + +Component timings measure their named stages. They do not measure a complete +SHA-256 proof. + +Run benchmarks separately. Record the commit, CPU, operating system, Rust +version, thread count, workload, and proof configuration with each result. +Record whether timings include setup and witness generation. +Use the release benchmark profile for comparisons; the `profiling` profile +uses different compiler settings. + +## Layout + +| Crate | Role | +| ------------------------- | ---------------------------------------------------------------------------------- | +| `circuit` | Circuit definitions, witness generation, and matrix operations. | +| `spartan` | Outer and inner sumchecks that reduce circuit constraints to evaluation claims. | +| `prover`, `verifier` | BitZ proving and verification, including virtual witness openings. | +| `pcs` | Binary commitments, ring-switching, and recursive Ligerito openings through Flock. | +| `gkr` | Grand-product reductions over the binary field. | +| `common`, `field`, `poly` | Protocol parameters, claims, field arithmetic, and polynomial operations. | +| `transcript`, `host` | Fiat-Shamir transcripts and proof serialization. | +| `tests` | Integration tests and proof comparison examples. | +| `bitz-cli` | Circuit proving tools and benchmarks in PR #68, under `tooling/cli`. | + +## Related work + +[BitZ-pcs](https://github.com/albert-garreta/BitZ-pcs), previously named +`f2z-pcs`, contains a separate research implementation and paper experiments. +Its [bitz-parity branch](https://github.com/albert-garreta/BitZ-pcs/tree/bitz-parity) +contains PCS transcript comparison work against this implementation. +Full Spartan-plus-BitZ parity remains separate work. + +The repositories have different interfaces and benchmark drivers. +Compare results only with matching workloads, proof configurations, and timing +definitions. + +See the [optimization tracker](https://github.com/worldfnd/BitZ/issues/41) +for current performance work. From 05b600f1fca47aacb5fb338671aa6e163364a87c Mon Sep 17 00:00:00 2001 From: zkfriendly Date: Wed, 16 Sep 2026 21:12:42 +0200 Subject: [PATCH 2/8] bitz snark --- README.md | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/README.md b/README.md index 874f0c8f..bbb11e56 100644 --- a/README.md +++ b/README.md @@ -1,21 +1,10 @@ # BitZ -**BitZ** is a hash-based polynomial commitment scheme (PCS) for commiting to polynomials with coeffients in a ring S (e.g a finite field F, integers Z) and proves evaluation claims over another arbitrary ring R. This repo provides an implementation of a concrete instantiation of this protocol where S is the integers Z and R is a Finite Field Fq. +**BitZ** is a hash-based polynomial commitment scheme (PCS) for commiting to polynomials with coeffients in a ring S (e.g a finite field F, integers Z) and proves evaluation claims over another arbitrary ring R. This repo provides a modular implementation of a concrete instantiation of this protocol where S is the integers Z and R is a Finite Field Fq. -The repository also implements a **Spartan polynomial interactive oracle proof -(PIOP)** for end-to-end circuit proving. Spartan reduces circuit constraints to -a witness evaluation claim. BitZ proves that claim against the committed -witness. **SHA-256** is the current workload for end-to-end proving and -benchmarking. +# BitZ-SNARK -BitZ folds integer values, then uses GKR over `GF(2^128)`. -Ring-switching and recursive Ligerito complete the opening. -The binary commitment backend uses -[Flock](https://github.com/succinctlabs/flock). -Virtualization lets circuits derive a larger witness `h = M(1 || f)` over `F_2` -from committed bits `f`. - -This is a research implementation. Current proofs do not provide zero knowledge. +This repo also implements a Spartan like PIOP using BitZ as its PCS which is then used to implement among others end to end SHA-256 proving and verifying. ## Build @@ -29,6 +18,8 @@ cargo fmt --all --check cargo clippy --workspace --all-targets ``` + + ## SHA-256 end-to-end proving The SHA-256 CLI and circuit benchmarks currently require `feat/all-circuit-benches` @@ -56,6 +47,7 @@ witness. The SHA-256 adapters expose input bits and outputs as public values. `--circuit` selects one of four adapters: + | Adapter | Workload | | ---------------------- | --------------------------------------------------------------------------------- | | `sha256-compression` | One raw compression block, with an optional initial state. | @@ -63,6 +55,7 @@ witness. The SHA-256 adapters expose input bits and outputs as public values. | `sha256-block-aligned` | A block-aligned message, including an empty message, with SHA-256 padding. | | `sha256-2kb` | A 2 KiB message with SHA-256 padding. | + Variable-length adapters default to one input block. The 2 KiB adapter uses 32 input blocks. Use `--num-blocks` to set the length of a chain or block-aligned message. @@ -120,6 +113,7 @@ uses different compiler settings. ## Layout + | Crate | Role | | ------------------------- | ---------------------------------------------------------------------------------- | | `circuit` | Circuit definitions, witness generation, and matrix operations. | @@ -132,6 +126,9 @@ uses different compiler settings. | `tests` | Integration tests and proof comparison examples. | | `bitz-cli` | Circuit proving tools and benchmarks in PR #68, under `tooling/cli`. | + + + ## Related work [BitZ-pcs](https://github.com/albert-garreta/BitZ-pcs), previously named @@ -145,4 +142,4 @@ Compare results only with matching workloads, proof configurations, and timing definitions. See the [optimization tracker](https://github.com/worldfnd/BitZ/issues/41) -for current performance work. +for current performance work. \ No newline at end of file From 8b7d6441528ca079b1eed7787b17fc99a7677c17 Mon Sep 17 00:00:00 2001 From: zkfriendly Date: Wed, 16 Sep 2026 21:27:01 +0200 Subject: [PATCH 3/8] core readme structure --- README.md | 140 ++++++++---------------------------------------------- 1 file changed, 20 insertions(+), 120 deletions(-) diff --git a/README.md b/README.md index bbb11e56..6cedbe44 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # BitZ -**BitZ** is a hash-based polynomial commitment scheme (PCS) for commiting to polynomials with coeffients in a ring S (e.g a finite field F, integers Z) and proves evaluation claims over another arbitrary ring R. This repo provides a modular implementation of a concrete instantiation of this protocol where S is the integers Z and R is a Finite Field Fq. +**BitZ** is a hash-based polynomial commitment scheme (PCS) for committing to polynomials with coefficients in a ring S (e.g a Finite Field F, integers Z) and proves evaluation claims over another arbitrary ring R. This repo provides a modular implementation of a concrete instantiation of this protocol where S is the integers Z and R is a Finite Field Fq. # BitZ-SNARK @@ -18,128 +18,28 @@ cargo fmt --all --check cargo clippy --workspace --all-targets ``` - - -## SHA-256 end-to-end proving - -The SHA-256 CLI and circuit benchmarks currently require `feat/all-circuit-benches` -([PR #68](https://github.com/worldfnd/BitZ/pull/68), built on -[PR #64](https://github.com/worldfnd/BitZ/pull/64)). -These tools are not yet on `main`. - -Select that branch before running the commands below: - -```sh -git fetch origin feat/all-circuit-benches -git switch feat/all-circuit-benches -``` - -Generate random inputs, prove eight SHA-256 compression steps, and verify the proof: - -```sh -cargo run --release -p bitz-cli -- circuit-e2e \ - --circuit sha256-chain --num-blocks 8 --threads 1 -``` - -The command runs circuit setup, witness generation, commitment, proving, and -verification. The verifier uses the public statement and proof without the -witness. The SHA-256 adapters expose input bits and outputs as public values. - -`--circuit` selects one of four adapters: - - -| Adapter | Workload | -| ---------------------- | --------------------------------------------------------------------------------- | -| `sha256-compression` | One raw compression block, with an optional initial state. | -| `sha256-chain` | A positive number of raw blocks from the standard initial state, without padding. | -| `sha256-block-aligned` | A block-aligned message, including an empty message, with SHA-256 padding. | -| `sha256-2kb` | A 2 KiB message with SHA-256 padding. | - - -Variable-length adapters default to one input block. The 2 KiB adapter uses -32 input blocks. Use `--num-blocks` to set the length of a chain or block-aligned -message. - -The CLI reports the opening path, circuit dimensions, and timings for each -stage. `total_prove_ms` includes commitment and proving. It excludes setup, -witness generation, and verification. Input generation and thread-pool -initialization occur outside the reported timings. - -## Benchmarks - -Run the SHA-256 circuit benchmarks with one Rayon worker: - -```sh -RAYON_NUM_THREADS=1 cargo bench -p bitz-cli --bench circuits -``` - -The suite measures all four adapters across six stages: end-to-end, setup, -witness generation, commitment, proving, and verification. -The end-to-end measurement includes all five individual stages. -Chain and block-aligned benchmark cases use one input block. -Use the CLI to measure other lengths. - -Run every benchmark once to check the complete suite: - -```sh -RAYON_NUM_THREADS=1 cargo bench -p bitz-cli --bench circuits -- --test -``` - -Input generation occurs outside measurements. End-to-end and setup benchmarks -use fresh instances for each sample. Other stages reuse a prepared instance -for each benchmark case. - -Component benchmarks are also available on `main`: - -```sh -# SHA-256 witness generation and matrix operations. -cargo bench -p circuit --bench sha256_matrix_products - -# Spartan proving and verification for SHA-256 constraints. -cargo bench -p spartan --bench sha256 - -# BitZ's GKR reduction. -cargo bench -p prover --bench prover -``` - -Component timings measure their named stages. They do not measure a complete -SHA-256 proof. - -Run benchmarks separately. Record the commit, CPU, operating system, Rust -version, thread count, workload, and proof configuration with each result. -Record whether timings include setup and witness generation. -Use the release benchmark profile for comparisons; the `profiling` profile -uses different compiler settings. +[todo]: end to end prove command and benchmarks ## Layout - -| Crate | Role | -| ------------------------- | ---------------------------------------------------------------------------------- | -| `circuit` | Circuit definitions, witness generation, and matrix operations. | -| `spartan` | Outer and inner sumchecks that reduce circuit constraints to evaluation claims. | -| `prover`, `verifier` | BitZ proving and verification, including virtual witness openings. | -| `pcs` | Binary commitments, ring-switching, and recursive Ligerito openings through Flock. | -| `gkr` | Grand-product reductions over the binary field. | -| `common`, `field`, `poly` | Protocol parameters, claims, field arithmetic, and polynomial operations. | -| `transcript`, `host` | Fiat-Shamir transcripts and proof serialization. | -| `tests` | Integration tests and proof comparison examples. | -| `bitz-cli` | Circuit proving tools and benchmarks in PR #68, under `tooling/cli`. | - - - +The workspace contains library crates under `crates/` and the `bitz-cli` package under `tooling/cli/`. + +| Path | Package | Role | +| ------------------- | ------------ | ---------------------------------------------------------------------------------- | +| `crates/circuit` | `circuit` | SHA-256 and ECDSA circuits, witness generation, and matrix operations. | +| `crates/spartan` | `spartan` | Outer and inner sumchecks that reduce circuit constraints to evaluation claims. | +| `crates/prover` | `prover` | BitZ proving, including direct and virtual witness openings. | +| `crates/verifier` | `verifier` | BitZ verification, including direct and virtual witness openings. | +| `crates/pcs` | `pcs` | Binary commitments, ring switching, and recursive Ligerito openings through Flock. | +| `crates/gkr` | `gkr` | Grand-product reductions over the binary field. | +| `crates/common` | `common` | Protocol parameters, shapes, claims, and virtual witness maps. | +| `crates/field` | `field` | Binary-field and prime-field arithmetic. | +| `crates/poly` | `poly` | Multilinear polynomials, equality polynomials, and evaluation operations. | +| `crates/transcript` | `transcript` | Fiat-Shamir transcripts, challenges, and proof bytes. | +| `crates/host` | `host` | Proof serialization and parsing. | +| `crates/tests` | `tests` | Integration tests and proof comparison examples. | +| `tooling/cli` | `bitz-cli` | SHA-256 proving CLI, circuit adapters, proof library, and circuit benchmarks. | ## Related work -[BitZ-pcs](https://github.com/albert-garreta/BitZ-pcs), previously named -`f2z-pcs`, contains a separate research implementation and paper experiments. -Its [bitz-parity branch](https://github.com/albert-garreta/BitZ-pcs/tree/bitz-parity) -contains PCS transcript comparison work against this implementation. -Full Spartan-plus-BitZ parity remains separate work. - -The repositories have different interfaces and benchmark drivers. -Compare results only with matching workloads, proof configurations, and timing -definitions. - -See the [optimization tracker](https://github.com/worldfnd/BitZ/issues/41) -for current performance work. \ No newline at end of file +[todo]: related work From 3240b2aeffab86d622d6cb2e4952d943cc18f1a7 Mon Sep 17 00:00:00 2001 From: zkfriendly Date: Wed, 16 Sep 2026 21:42:07 +0200 Subject: [PATCH 4/8] add prove and benchmark commands --- README.md | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 6cedbe44..11b1c632 100644 --- a/README.md +++ b/README.md @@ -18,7 +18,40 @@ cargo fmt --all --check cargo clippy --workspace --all-targets ``` -[todo]: end to end prove command and benchmarks +## Prove and verify + +Prove eight SHA-256 compression steps and verify the proof: + +```sh +cargo run --release -p bitz-cli -- circuit-e2e \ + --circuit sha256-chain --num-blocks 8 --threads 1 +``` + +The command generates random inputs and reports timings for each proof stage. +All input and output bits are public. +Select the workload with `--circuit`: + +| Circuit | Workload | +| ---------------------- | ------------------------------------------------------------------------- | +| `sha256-compression` | One raw block without padding. | +| `sha256-chain` | One or more raw blocks without padding. | +| `sha256-block-aligned` | A block-aligned message with SHA-256 padding; empty messages are allowed. | +| `sha256-2kb` | A 2 KiB message with SHA-256 padding. | + +Use `--num-blocks` to set the chain or block-aligned message length in 64-byte blocks. +Use `--threads` to set the number of worker threads. + +## Benchmarks + +Run all SHA-256 circuit benchmarks with one Rayon worker: + +```sh +RAYON_NUM_THREADS=1 cargo bench -p bitz-cli --bench circuits +``` + +The suite measures all four workloads through the complete proof process. It also measures setup, witness generation, commitment, proving, and verification separately. Chain and block-aligned benchmarks use one input block. + +Set `RAYON_NUM_THREADS` to change the number of worker threads. ## Layout From 60af9ae4892fe3834f73e092bbe131c4746ae2c3 Mon Sep 17 00:00:00 2001 From: zkfriendly Date: Wed, 16 Sep 2026 21:53:25 +0200 Subject: [PATCH 5/8] acknowledgements --- README.md | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 11b1c632..071455da 100644 --- a/README.md +++ b/README.md @@ -8,8 +8,7 @@ This repo also implements a Spartan like PIOP using BitZ as its PCS which is the ## Build -The workspace uses Rust **1.97.1**, pinned in `rust-toolchain.toml`. -Run these commands from the repository root: +The workspace uses Rust **1.97.1**, pinned in `rust-toolchain.toml`. Run these commands from the repository root: ```sh cargo build --release --workspace @@ -38,7 +37,7 @@ Select the workload with `--circuit`: | `sha256-block-aligned` | A block-aligned message with SHA-256 padding; empty messages are allowed. | | `sha256-2kb` | A 2 KiB message with SHA-256 padding. | -Use `--num-blocks` to set the chain or block-aligned message length in 64-byte blocks. +`--num-blocks` to set the chain or block-aligned message length in 64-byte blocks. Use `--threads` to set the number of worker threads. ## Benchmarks @@ -73,6 +72,20 @@ The workspace contains library crates under `crates/` and the `bitz-cli` package | `crates/tests` | `tests` | Integration tests and proof comparison examples. | | `tooling/cli` | `bitz-cli` | SHA-256 proving CLI, circuit adapters, proof library, and circuit benchmarks. | -## Related work +## Optimizations -[todo]: related work +[link to optimizations used] + +## Acknowledgments + +We thank the authors and maintainers of the projects that support this implementation: + +- **[Flock](https://github.com/succinctlabs/flock) and Ligerito.** We use Ligerito through Flock's `flock-core` for our internal binary-field PCS. +- **[Spongefish](https://github.com/arkworks-rs/spongefish).** We use Spongefish for Fiat–Shamir transcripts, challenge generation, and message encoding. +- **[Nethermind's crypto-primitives](https://github.com/NethermindEth/crypto-primitives).** We use its field traits and procedural macros throughout our arithmetic and polynomial code. +- **[Freigen](https://github.com/reilabs/freigen).** Our SHA-256 circuit follows Freigen's design. + Our P-256 circuit ports its Lean implementation. +- **[Binius64](https://github.com/binius-zk/binius64).** We adapt field reduction and interpolation routines from Binius64. + We also use `binius-field` for benchmark comparisons. +- **[WHIR](https://github.com/worldfnd/whir) and [Zinc+](https://github.com/NethermindEth/zinc-plus).** We adapt multilinear evaluation and workload sizing from WHIR. + Our dense multilinear representation derives from Zinc+. From 41f20f1751f19ec4206107446173dacc511a8e79 Mon Sep 17 00:00:00 2001 From: Shreyas Londhe <62744899+shreyas-londhe@users.noreply.github.com> Date: Thu, 17 Sep 2026 08:00:17 +0530 Subject: [PATCH 6/8] Improve mathematical notation in README Updated mathematical notation in the README to use LaTeX formatting. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 071455da..a44b1267 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # BitZ -**BitZ** is a hash-based polynomial commitment scheme (PCS) for committing to polynomials with coefficients in a ring S (e.g a Finite Field F, integers Z) and proves evaluation claims over another arbitrary ring R. This repo provides a modular implementation of a concrete instantiation of this protocol where S is the integers Z and R is a Finite Field Fq. +**BitZ** is a hash-based polynomial commitment scheme (PCS) for committing to polynomials with coefficients in a ring $S$ (e.g a Finite Field $\mathbb{F}$, integers $\mathbb{Z}$ and proves evaluation claims over another arbitrary ring $R$. This repo provides a modular implementation of a concrete instantiation of this protocol where $S$ is the integers $\mathbb{Z}$ and $R$ is a Finite Field $\mathbb{F}_q$. # BitZ-SNARK From bfbe165732452c453ac5a8d067fc19f606753718 Mon Sep 17 00:00:00 2001 From: Shreyas Londhe <62744899+shreyas-londhe@users.noreply.github.com> Date: Thu, 17 Sep 2026 08:02:02 +0530 Subject: [PATCH 7/8] Fix duplicate entry for WHIR and Zinc+ in README Removed duplicate entry for WHIR and Zinc+. --- README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/README.md b/README.md index a44b1267..020e8606 100644 --- a/README.md +++ b/README.md @@ -87,5 +87,4 @@ We thank the authors and maintainers of the projects that support this implement Our P-256 circuit ports its Lean implementation. - **[Binius64](https://github.com/binius-zk/binius64).** We adapt field reduction and interpolation routines from Binius64. We also use `binius-field` for benchmark comparisons. -- **[WHIR](https://github.com/worldfnd/whir) and [Zinc+](https://github.com/NethermindEth/zinc-plus).** We adapt multilinear evaluation and workload sizing from WHIR. - Our dense multilinear representation derives from Zinc+. +- **[WHIR](https://github.com/worldfnd/whir) and [Zinc+](https://github.com/NethermindEth/zinc-plus).** We adapt multilinear evaluation and workload sizing from WHIR. Our dense multilinear representation derives from Zinc+. From d21bb1b8b3aa117e9980e937076473bf90b785cd Mon Sep 17 00:00:00 2001 From: zkfriendly <154443027+zkfriendly@users.noreply.github.com> Date: Thu, 17 Sep 2026 10:56:12 +0200 Subject: [PATCH 8/8] add missing ) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 020e8606..c747a14b 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # BitZ -**BitZ** is a hash-based polynomial commitment scheme (PCS) for committing to polynomials with coefficients in a ring $S$ (e.g a Finite Field $\mathbb{F}$, integers $\mathbb{Z}$ and proves evaluation claims over another arbitrary ring $R$. This repo provides a modular implementation of a concrete instantiation of this protocol where $S$ is the integers $\mathbb{Z}$ and $R$ is a Finite Field $\mathbb{F}_q$. +**BitZ** is a hash-based polynomial commitment scheme (PCS) for committing to polynomials with coefficients in a ring $S$ (e.g a Finite Field $\mathbb{F}$, integers $\mathbb{Z}$) and proves evaluation claims over another arbitrary ring $R$. This repo provides a modular implementation of a concrete instantiation of this protocol where $S$ is the integers $\mathbb{Z}$ and $R$ is a Finite Field $\mathbb{F}_q$. # BitZ-SNARK