Merge branch 'main' into example-reorg

.github/workflows/large-tests.yml

@@ -11,7 +11,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - name: nanoGPT Mock

.github/workflows/release.yml

@@ -45,7 +45,7 @@ jobs:
     steps:
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - name: Checkout repo

.github/workflows/rust.yml

@@ -26,7 +26,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - name: Build
@@ -38,7 +38,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - name: Docs
@@ -50,7 +50,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -73,7 +73,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -106,7 +106,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -139,7 +139,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -172,7 +172,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -189,7 +189,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: jetli/wasm-pack-action@v0.4.0
@@ -198,8 +198,10 @@ jobs:
         #   chromedriver-version: "115.0.5790.102"
       - name: Install wasm32-unknown-unknown
         run: rustup target add wasm32-unknown-unknown
+      - name: Install wasm runner
+        run: cargo install wasm-server-runner
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-01-04-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
       - name: Run wasm verifier tests
         # on mac:
         #   AR=/opt/homebrew/opt/llvm/bin/llvm-ar CC=/opt/homebrew/opt/llvm/bin/clang wasm-pack test --firefox --headless -- -Z build-std="panic_abort,std" --features web
@@ -212,7 +214,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -229,15 +231,13 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
-      - name: public outputs and tolerance > 0
-        run: cargo nextest run --release --verbose tests::mock_tolerance_public_outputs_ --test-threads 32
       - name: public outputs + batch size == 10
         run: cargo nextest run --release --verbose tests::mock_large_batch_public_outputs_ --test-threads 32
       - name: kzg inputs
@@ -286,7 +286,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -303,28 +303,16 @@ jobs:
         with:
           node-version: "18.12.1"
           cache: "pnpm"
-      - name: Install dependencies for js tests and in-browser-evm-verifier package
+      - name: Install dependencies
         run: |
           pnpm install --no-frozen-lockfile
-          pnpm install --dir ./in-browser-evm-verifier --no-frozen-lockfile
         env:
           CI: false
           NODE_ENV: development
-      - name: Build wasm package for nodejs target.
-        run: |
-          wasm-pack build --release --target nodejs --out-dir ./in-browser-evm-verifier/nodejs . -- -Z build-std="panic_abort,std"
-      - name: Replace memory definition in nodejs
-        run: |
-          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" in-browser-evm-verifier/nodejs/ezkl.js
-      - name: Build @ezkljs/verify package
-        run: |
-          cd in-browser-evm-verifier
-          pnpm build:commonjs
-          cd ..
       - name: Install solc
         run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
       - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev b320f350156a0fb15c2eb13dc380deb2367c4474 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
       - name: KZG prove and verify tests (EVM + VK rendered seperately)
         run: cargo nextest run --release --verbose tests_evm::kzg_evm_prove_and_verify_render_seperately_ --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg all)
@@ -357,15 +345,18 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: jetli/wasm-pack-action@v0.4.0
       - name: Add wasm32-unknown-unknown target
         run: rustup target add wasm32-unknown-unknown
 
+      - name: Install wasm-server-runner
+        run: cargo install wasm-server-runner
+
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-01-04-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
       - uses: actions/checkout@v3
       - name: Use pnpm 8
         uses: pnpm/action-setup@v2
@@ -376,7 +367,7 @@ jobs:
         with:
           node-version: "18.12.1"
           cache: "pnpm"
-      - name: Install dependencies for js tests
+      - name: Install dependencies
         run: |
           pnpm install --no-frozen-lockfile
         env:
@@ -425,11 +416,11 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-01-04-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
       - uses: actions/checkout@v3
       - uses: baptiste0928/cargo-install@v1
         with:
@@ -459,7 +450,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -469,7 +460,7 @@ jobs:
       - name: Install solc
         run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
       - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev b320f350156a0fb15c2eb13dc380deb2367c4474 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
       - name: fuzz tests (EVM)
         run: cargo nextest run --release --verbose tests_evm::kzg_evm_fuzz_ --test-threads 2
       # - name: fuzz tests
@@ -482,7 +473,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -500,7 +491,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -512,12 +503,12 @@ jobs:
 
   prove-and-verify-aggr-tests:
     runs-on: large-self-hosted
-    needs: [build, library-tests]
+    needs: [build, library-tests, python-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -525,16 +516,16 @@ jobs:
           crate: cargo-nextest
           locked: true
       - name: KZG )tests
-        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 4 -- --include-ignored
+        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 8 -- --include-ignored
 
   prove-and-verify-aggr-evm-tests:
     runs-on: large-self-hosted
-    needs: [build, library-tests]
+    needs: [build, library-tests, python-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -544,7 +535,7 @@ jobs:
       - name: Install solc
         run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
       - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev b320f350156a0fb15c2eb13dc380deb2367c4474 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
       - name: KZG prove and verify aggr tests
         run: cargo nextest run  --release --verbose tests_evm::kzg_evm_aggr_prove_and_verify_::t --test-threads 4 -- --include-ignored
 
@@ -555,7 +546,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -577,7 +568,7 @@ jobs:
           python-version: "3.7"
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - name: Install solc
@@ -585,9 +576,9 @@ jobs:
       - name: Setup Virtual Env and Install python dependencies
         run: python -m venv .env; source .env/bin/activate; pip install -r requirements.txt;
       - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev b320f350156a0fb15c2eb13dc380deb2367c4474 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
       - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; maturin develop --features python-bindings --release
       - name: Run pytest
         run: source .env/bin/activate; pytest -vv
 
@@ -601,7 +592,7 @@ jobs:
           python-version: "3.7"
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -611,7 +602,7 @@ jobs:
       - name: Setup Virtual Env and Install python dependencies
         run: python -m venv .env; source .env/bin/activate; pip install -r requirements.txt;
       - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; maturin develop --features python-bindings --release
       - name: Div rebase
         run: source .env/bin/activate; cargo nextest run --release --verbose tests::accuracy_measurement_div_rebase_
       - name: Public inputs
@@ -632,7 +623,7 @@ jobs:
           python-version: "3.9"
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -642,11 +633,11 @@ jobs:
       - name: Install solc
         run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
       - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev b320f350156a0fb15c2eb13dc380deb2367c4474 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
       - name: Setup Virtual Env and Install python dependencies
         run: python -m venv .env; source .env/bin/activate; pip install -r requirements.txt;
       - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; maturin develop --features python-bindings --release
       # - name: authenticate-kaggle-cli
       #   shell: bash
       #   env:

.github/workflows/wasm.yml

@@ -1,4 +1,4 @@
-name: Build and Publish EZKL npm packages (wasm bindings and in-browser evm verifier)
+name: Build and Publish WASM<>JS Bindings
 
 on:
   workflow_dispatch:
@@ -14,7 +14,7 @@ defaults:
   run:
     working-directory: .
 jobs:
-  publish-wasm-bindings:
+  wasm-publish:
     name: publish-wasm-bindings
     runs-on: ubuntu-latest
     if: startsWith(github.ref, 'refs/tags/')
@@ -22,15 +22,18 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: jetli/wasm-pack-action@v0.4.0
       - name: Add wasm32-unknown-unknown target
         run: rustup target add wasm32-unknown-unknown
 
+      - name: Install wasm-server-runner
+        run: cargo install wasm-server-runner
+
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-01-04-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
       - name: Install binaryen
         run: |
             set -e
@@ -174,40 +177,3 @@ jobs:
           npm publish
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-  in-browser-evm-ver-publish:
-    name: publish-in-browser-evm-verifier-package
-    needs: ["publish-wasm-bindings"]
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    steps:
-      - uses: actions/checkout@v4
-      - name: Update version in package.json
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          sed -i "s|\"version\": \".*\"|\"version\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
-      - name: Update @ezkljs/engine version in package.json
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          sed -i "s|\"@ezkljs/engine\": \".*\"|\"@ezkljs/engine\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
-      - name: Update the engine import in in-browser-evm-verifier to use @ezkljs/engine package instead of the local one;
-        run: |
-          sed -i "s|import { encodeVerifierCalldata } from '../nodejs/ezkl';|import { encodeVerifierCalldata } from '@ezkljs/engine';|" in-browser-evm-verifier/src/index.ts
-      - name: Set up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: "18.12.1"
-          registry-url: "https://registry.npmjs.org"
-      - name: Publish to npm
-        run: |
-          cd in-browser-evm-verifier
-          npm install
-          npm run build
-          npm ci
-          npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.gitignore

@@ -45,7 +45,6 @@ var/
 *.whl
 *.bak
 node_modules
-/dist
 timingData.json
 !tests/wasm/pk.key
 !tests/wasm/vk.key

Cargo.toml

@@ -15,96 +15,70 @@ crate-type = ["cdylib", "rlib"]
 
 
 [dependencies]
-halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch = "main" }
-halo2_proofs = { git = "https://github.com/zkonduit/halo2", branch = "main" }
-halo2curves = { git = "https://github.com/privacy-scaling-explorations/halo2curves", rev = "9fff22c", features = [
-    "derive_serde",
-] }
+halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch= "main" }
+halo2_proofs = { git = "https://github.com/zkonduit/halo2", branch= "main"  }
+halo2curves = { version = "0.6.0", features = ["derive_serde"] }
 rand = { version = "0.8", default_features = false }
 itertools = { version = "0.10.3", default_features = false }
-clap = { version = "4.3.3", features = ["derive"] }
+clap = { version = "4.3.3", features = ["derive"]}
 serde = { version = "1.0.126", features = ["derive"], optional = true }
-serde_json = { version = "1.0.97", default_features = false, features = [
-    "float_roundtrip",
-    "raw_value",
-], optional = true }
+serde_json = { version = "1.0.97", default_features = false, features = ["float_roundtrip", "raw_value"], optional = true }
 log = { version = "0.4.17", default_features = false, optional = true }
 thiserror = { version = "1.0.38", default_features = false }
 hex = { version = "0.4.3", default_features = false }
 halo2_wrong_ecc = { git = "https://github.com/zkonduit/halo2wrong", branch = "ac/chunked-mv-lookup", package = "ecc" }
-snark-verifier = { git = "https://github.com/zkonduit/snark-verifier", branch = "ac/chunked-mv-lookup", features = [
-    "derive_serde",
-] }
-halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier", branch = "main" }
-maybe-rayon = { version = "0.1.1", default_features = false }
+snark-verifier = { git = "https://github.com/zkonduit/snark-verifier", branch = "ac/chunked-mv-lookup", features=["derive_serde"]}
+halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier",  branch= "main" }
+maybe-rayon = { version = "0.1.1",  default_features = false }
 bincode = { version = "1.3.3", default_features = false }
 ark-std = { version = "^0.3.0", default-features = false }
 unzip-n = "0.1.2"
 num = "0.4.1"
-portable-atomic = "1.6.0"
-tosubcommand = { git = "https://github.com/zkonduit/enum_to_subcommand", package = "tosubcommand" }
-
 
 # evm related deps
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-ethers = { version = "2.0.11", default_features = false, features = [
-    "ethers-solc",
-] }
-indicatif = { version = "0.17.5", features = ["rayon"] }
-gag = { version = "1.0.0", default_features = false }
+ethers = { version = "2.0.7", default_features = false, features = ["ethers-solc"] }
+indicatif = {version = "0.17.5", features = ["rayon"]}
+gag =  { version = "1.0.0", default_features = false}
 instant = { version = "0.1" }
-reqwest = { version = "0.11.14", default-features = false, features = [
-    "default-tls",
-    "multipart",
-    "stream",
-] }
+reqwest = { version = "0.11.14", default-features = false, features = ["default-tls", "multipart", "stream"] }
 openssl = { version = "0.10.55", features = ["vendored"] }
 postgres = "0.19.5"
 pg_bigdecimal = "0.1.5"
 lazy_static = "1.4.0"
-colored_json = { version = "3.0.1", default_features = false, optional = true }
+colored_json =  { version = "3.0.1",  default_features = false, optional = true}
 plotters = { version = "0.3.0", default_features = false, optional = true }
 regex = { version = "1", default_features = false }
-tokio = { version = "1.26.0", default_features = false, features = [
-    "macros",
-    "rt",
-] }
+tokio = { version = "1.26.0",  default_features = false, features = ["macros", "rt"] }
 tokio-util = { version = "0.7.9", features = ["codec"] }
-pyo3 = { version = "0.20.2", features = [
-    "extension-module",
-    "abi3-py37",
-    "macros",
-], default_features = false, optional = true }
-pyo3-asyncio = { version = "0.20.0", features = [
-    "attributes",
-    "tokio-runtime",
-], default_features = false, optional = true }
+pyo3 = { version = "0.20.2", features = ["extension-module", "abi3-py37", "macros"],  default_features = false, optional = true }
+pyo3-asyncio = { version = "0.20.0",  features = ["attributes", "tokio-runtime"],  default_features = false, optional = true }
 pyo3-log = { version = "0.9.0", default_features = false, optional = true }
-tract-onnx = { git = "https://github.com/sonos/tract/", rev = "7b1aa33b2f7d1f19b80e270c83320f0f94daff69", default_features = false, optional = true }
+tract-onnx = { git = "https://github.com/sonos/tract/", rev= "7b1aa33b2f7d1f19b80e270c83320f0f94daff69", default_features = false, optional = true }
 tabled = { version = "0.12.0", optional = true }
 
 
 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
-colored = { version = "2.0.0", default_features = false, optional = true }
-env_logger = { version = "0.10.0", default_features = false, optional = true }
+colored = { version = "2.0.0",  default_features = false, optional = true}
+env_logger = { version = "0.10.0",  default_features = false, optional = true}
 chrono = "0.4.31"
 sha256 = "1.4.0"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.2.8", features = ["js"] }
-instant = { version = "0.1", features = ["wasm-bindgen", "inaccurate"] }
+instant = { version = "0.1", features = [ "wasm-bindgen", "inaccurate" ] }
 
 [target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
-wasm-bindgen-rayon = { version = "1.0", optional = true }
+wasm-bindgen-rayon = { version = "1.0", optional=true }
 wasm-bindgen-test = "0.3.34"
 serde-wasm-bindgen = "0.4"
-wasm-bindgen = { version = "0.2.81", features = ["serde-serialize"] }
+wasm-bindgen = { version = "0.2.81", features = ["serde-serialize"]}
 console_error_panic_hook = "0.1.7"
 wasm-bindgen-console-logger = "0.1.1"
 
 
 [dev-dependencies]
-criterion = { version = "0.3", features = ["html_reports"] }
+criterion = {version = "0.3",  features = ["html_reports"]}
 tempfile = "3.3.0"
 lazy_static = "1.4.0"
 mnist = "0.5"
@@ -176,32 +150,18 @@ required-features = ["ezkl"]
 [features]
 web = ["wasm-bindgen-rayon"]
 default = ["ezkl", "mv-lookup"]
+render = ["halo2_proofs/dev-graph", "plotters"]
 onnx = ["dep:tract-onnx"]
 python-bindings = ["pyo3", "pyo3-log", "pyo3-asyncio"]
-ezkl = [
-    "onnx",
-    "serde",
-    "serde_json",
-    "log",
-    "colored",
-    "env_logger",
-    "tabled/color",
-    "colored_json",
-    "halo2_proofs/circuit-params",
-]
-mv-lookup = [
-    "halo2_proofs/mv-lookup",
-    "snark-verifier/mv-lookup",
-    "halo2_solidity_verifier/mv-lookup",
-]
+ezkl = ["onnx", "serde", "serde_json", "log", "colored", "env_logger", "tabled/color", "colored_json", "halo2_proofs/circuit-params"]
+mv-lookup = ["halo2_proofs/mv-lookup", "snark-verifier/mv-lookup", "halo2_solidity_verifier/mv-lookup"]
 det-prove = []
 icicle = ["halo2_proofs/icicle_gpu"]
 empty-cmd = []
-no-banner = []
 
 # icicle patch to 0.1.0 if feature icicle is enabled
 [patch.'https://github.com/ingonyama-zk/icicle']
-icicle = { git = "https://github.com/ingonyama-zk/icicle?rev=45b00fb", package = "icicle", branch = "fix/vhnat/ezkl-build-fix" }
+icicle = { git = "https://github.com/ingonyama-zk/icicle?rev=45b00fb", package = "icicle", branch = "fix/vhnat/ezkl-build-fix"}
 
 [profile.release]
-rustflags = ["-C", "relocation-model=pic"]
+rustflags = [ "-C", "relocation-model=pic" ]

README.md

@@ -74,10 +74,6 @@ For more details visit the [docs](https://docs.ezkl.xyz).
 
 Build the auto-generated rust documentation and open the docs in your browser locally. `cargo doc --open`
 
-#### In-browser EVM verifier
-
-As an alternative to running the native Halo2 verifier as a WASM binding in the browser, you can use the in-browser EVM verifier. The source code of which you can find in the `in-browser-evm-verifier` directory and a README with instructions on how to use it.
-
 
 ### building the project 🔨
 

examples/conv2d_mnist/main.rs

@@ -6,7 +6,6 @@ use ezkl::fieldutils;
 use ezkl::fieldutils::i32_to_felt;
 use ezkl::tensor::*;
 use halo2_proofs::dev::MockProver;
-use halo2_proofs::poly::commitment::Params;
 use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
 use halo2_proofs::{
     circuit::{Layouter, SimpleFloorPlanner, Value},
@@ -490,7 +489,6 @@ pub fn runconv() {
         strategy,
         pi_for_real_prover,
         &mut transcript,
-        params.n(),
     );
     assert!(verify.is_ok());
 

examples/notebooks/applications/data_attest_hashed.ipynb

@@ -309,7 +309,7 @@
             "metadata": {},
             "outputs": [],
             "source": [
-                "print(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]))"
+                "print(ezkl.string_to_felt(res['processed_outputs']['poseidon_hash'][0]))"
             ]
         },
         {
@@ -325,7 +325,7 @@
             "metadata": {},
             "outputs": [],
             "source": [
-                "from web3 import Web3, HTTPProvider\n",
+                "from web3 import Web3, HTTPProvider, utils\n",
                 "from solcx import compile_standard\n",
                 "from decimal import Decimal\n",
                 "import json\n",
@@ -338,7 +338,7 @@
                 "\n",
                 "def test_on_chain_data(res):\n",
                 "    # Step 0: Convert the tensor to a flat list\n",
-                "    data = [int(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
+                "    data = [int(ezkl.string_to_felt(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
                 "\n",
                 "    # Step 1: Prepare the data\n",
                 "    # Step 2: Prepare and compile the contract.\n",
@@ -648,7 +648,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.9.13"
         },
         "orig_nbformat": 4
     },

examples/notebooks/applications/ezkl_demo.ipynb

@@ -695,7 +695,7 @@
         "formatted_output = \"[\"\n",
         "for i, value in enumerate(proof[\"instances\"]):\n",
         "    for j, field_element in enumerate(value):\n",
-        "        onchain_input_array.append(ezkl.felt_to_big_endian(field_element))\n",
+        "        onchain_input_array.append(ezkl.string_to_felt(field_element))\n",
         "        formatted_output += str(onchain_input_array[-1])\n",
         "        if j != len(value) - 1:\n",
         "            formatted_output += \", \"\n",
@@ -705,7 +705,7 @@
         "# copy them over to remix and see if they verify\n",
         "# What happens when you change a value?\n",
         "print(\"pubInputs: \", formatted_output)\n",
-        "print(\"proof: \", proof[\"proof\"])"
+        "print(\"proof: \", \"0x\" + proof[\"proof\"])"
       ]
     },
     {

examples/notebooks/applications/solvency.ipynb

@@ -126,7 +126,7 @@
         "# Loop through each element in the y tensor\n",
         "for e in user_preimages:\n",
         "    # Apply the custom function and append the result to the list\n",
-        "    users.append(ezkl.poseidon_hash([ezkl.float_to_felt(e, 0)])[0])\n",
+        "    users.append(ezkl.poseidon_hash([ezkl.float_to_string(e, 0)])[0])\n",
         "\n",
         "users_t = torch.tensor(user_preimages)\n",
         "users_t = users_t.reshape(1, 6)\n",
@@ -303,7 +303,7 @@
         "# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
         "# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
         "witness = json.load(open(witness_path, \"r\"))\n",
-        "witness[\"outputs\"][0] = [ezkl.float_to_felt(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_string(1.0, 0)]\n",
         "json.dump(witness, open(witness_path, \"w\"))"
       ]
     },
@@ -417,7 +417,7 @@
         "# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
         "# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
         "witness = json.load(open(witness_path, \"r\"))\n",
-        "witness[\"outputs\"][0] = [ezkl.float_to_felt(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_string(1.0, 0)]\n",
         "json.dump(witness, open(witness_path, \"w\"))\n"
       ]
     },
@@ -510,7 +510,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.9.15"
+      "version": "3.9.13"
     }
   },
   "nbformat": 4,

examples/notebooks/applications/tictactoe_autoencoder.ipynb

@@ -633,7 +633,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [11])"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [4])"
             ]
         },
         {
@@ -664,6 +664,7 @@
                 "    compiled_model_path,\n",
                 "    vk_path,\n",
                 "    pk_path,\n",
+                "    \n",
                 ")"
             ]
         },

examples/notebooks/applications/world_rotation.ipynb

@@ -503,11 +503,11 @@
     "pyplot.arrow(0, 0, 1, 0, width=0.02, alpha=0.5)\n",
     "pyplot.arrow(0, 0, 0, 1, width=0.02, alpha=0.5)\n",
     "\n",
-    "arrow_x = ezkl.felt_to_float(witness['outputs'][0][0], out_scale)\n",
-    "arrow_y = ezkl.felt_to_float(witness['outputs'][0][1], out_scale)\n",
+    "arrow_x = ezkl.string_to_float(witness['outputs'][0][0], out_scale)\n",
+    "arrow_y = ezkl.string_to_float(witness['outputs'][0][1], out_scale)\n",
     "pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)\n",
-    "arrow_x = ezkl.felt_to_float(witness['outputs'][0][2], out_scale)\n",
-    "arrow_y = ezkl.felt_to_float(witness['outputs'][0][3], out_scale)\n",
+    "arrow_x = ezkl.string_to_float(witness['outputs'][0][2], out_scale)\n",
+    "arrow_y = ezkl.string_to_float(witness['outputs'][0][3], out_scale)\n",
     "pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)"
    ]
   }

examples/notebooks/data_science/set_membership.ipynb

@@ -122,8 +122,8 @@
         "# Loop through each element in the y tensor\n",
         "for e in y_input:\n",
         "    # Apply the custom function and append the result to the list\n",
-        "    print(ezkl.float_to_felt(e,7))\n",
-        "    result.append(ezkl.poseidon_hash([ezkl.float_to_felt(e, 7)])[0])\n",
+        "    print(ezkl.float_to_string(e,7))\n",
+        "    result.append(ezkl.poseidon_hash([ezkl.float_to_string(e, 7)])[0])\n",
         "\n",
         "y = y.unsqueeze(0)\n",
         "y = y.reshape(1, 9)\n",

examples/notebooks/deep_learning/mnist_gan_proof_splitting.ipynb

@@ -343,6 +343,7 @@
                 "         compiled_model_path,\n",
                 "         vk_path,\n",
                 "         pk_path,\n",
+                "         compress_selectors=True,\n",
                 "      )\n",
                 "\n",
                 "    assert res == True\n",

examples/onnx/gather_nd/gen.py

@@ -1,48 +0,0 @@
-from torch import nn
-import json
-import numpy as np
-import tf2onnx
-
-
-import tensorflow as tf
-from tensorflow.keras.layers import *
-from tensorflow.keras.models import Model
-
-
-# gather_nd in tf then export to onnx
-
-
-
-
-x = in1 = Input((15, 18,))
-w = in2 = Input((15, 1), dtype=tf.int32)
-x = tf.gather_nd(x, w, batch_dims=1)
-tm = Model((in1, in2), x )
-tm.summary()
-tm.compile(optimizer='adam', loss='mse')
-
-shape = [1, 15, 18]
-index_shape = [1, 15, 1]
-# After training, export to onnx (network.onnx) and create a data file (input.json)
-x = 0.1*np.random.rand(1,*shape)
-# w = random int tensor
-w = np.random.randint(0, 10, index_shape)
-
-spec = tf.TensorSpec(shape, tf.float32, name='input_0')
-index_spec = tf.TensorSpec(index_shape, tf.int32, name='input_1')
-
-model_path = "network.onnx"
-
-tf2onnx.convert.from_keras(tm, input_signature=[spec, index_spec], inputs_as_nchw=['input_0', 'input_1'], opset=12, output_path=model_path)
-
-
-d = x.reshape([-1]).tolist()
-d1 = w.reshape([-1]).tolist()
-
-
-data = dict(
-    input_data=[d, d1],
-)
-
-# Serialize data into file:
-json.dump(data, open("input.json", 'w'))

examples/onnx/scatter_nd/gen.py

@@ -1,76 +0,0 @@
-import torch
-import torch.nn as nn
-import sys
-import json
-
-sys.path.append("..")
-
-class Model(nn.Module):
-    """
-    Just one Linear layer
-    """
-    def __init__(self, configs):
-        super(Model, self).__init__()
-        self.seq_len = configs.seq_len
-        self.pred_len = configs.pred_len
-
-        # Use this line if you want to visualize the weights
-        # self.Linear.weight = nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len,self.seq_len]))
-        self.channels = configs.enc_in
-        self.individual = configs.individual
-        if self.individual:
-            self.Linear = nn.ModuleList()
-            for i in range(self.channels):
-                self.Linear.append(nn.Linear(self.seq_len,self.pred_len))
-        else:
-            self.Linear = nn.Linear(self.seq_len, self.pred_len)
-
-    def forward(self, x):
-        # x: [Batch, Input length, Channel]
-        if self.individual:
-            output = torch.zeros([x.size(0),self.pred_len,x.size(2)],dtype=x.dtype).to(x.device)
-            for i in range(self.channels):
-                output[:,:,i] = self.Linear[i](x[:,:,i])
-            x = output
-        else:
-            x = self.Linear(x.permute(0,2,1)).permute(0,2,1)
-        return x # [Batch, Output length, Channel]
-
-class Configs:
-    def __init__(self, seq_len, pred_len, enc_in=321, individual=True):
-      self.seq_len = seq_len
-      self.pred_len = pred_len
-      self.enc_in = enc_in
-      self.individual = individual
-
-model = 'Linear'
-seq_len = 10
-pred_len = 4
-enc_in = 3
-
-configs = Configs(seq_len, pred_len, enc_in, True)
-circuit = Model(configs)
-
-x = torch.randn(1, seq_len, pred_len)
-
-
-torch.onnx.export(circuit, x, "network.onnx",
-                  export_params=True,        # store the trained parameter weights inside the model file
-                  opset_version=15,          # the ONNX version to export the model to
-                  do_constant_folding=True,  # whether to execute constant folding for optimization
-                  # the model's input names
-                  input_names=['input'],
-                  output_names=['output'],  # the model's output names
-                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
-                                'output': {0: 'batch_size'}})
-
-
-d1 = ((x).detach().numpy()).reshape([-1]).tolist()
-
-
-data = dict(
-    input_data=[d1],
-)
-
-# Serialize data into file:
-json.dump(data, open("input.json", 'w'))

examples/onnx/scatter_nd/input.json

@@ -1 +0,0 @@
-{"input_data": [[0.1874287724494934, 1.0498261451721191, 0.22384068369865417, 1.048445224761963, -0.5670360326766968, -0.38653188943862915, 0.12878702580928802, -2.3675858974456787, 0.5800458192825317, -0.43653929233551025, -0.2511898875236511, 0.3324051797389984, 0.27960312366485596, 0.4763695001602173, 0.3796705901622772, 1.1334782838821411, -0.87981778383255, -1.2451434135437012, 0.7672272324562073, -0.24404007196426392, -0.6875824928283691, 0.3619358539581299, -0.10131897777318954, 0.7169521450996399, 1.6585893630981445, -0.5451845526695251, 0.429487019777298, 0.7426952123641968, -0.2543637454509735, 0.06546942889690399, 0.7939824461936951, 0.1579471379518509, -0.043604474514722824, -0.8621711730957031, -0.5344759821891785, -0.05880478024482727, -0.17351101338863373, 0.5095029473304749, -0.7864817976951599, -0.449171245098114]]}

in-browser-evm-verifier/README.md

@@ -1,60 +0,0 @@
-# inbrowser-evm-verify
-
-We would like the Solidity verifier to be canonical and usually all you ever need. For this, we need to be able to run that verifier in browser.
-
-## How to use (Node js)
-
-```ts 
-import localEVMVerify from '@ezkljs/verify';
-
-// Load in the proof file as a buffer
-const proofFileBuffer = fs.readFileSync(`${path}/${example}/proof.pf`)
-
-// Stringified EZKL evm verifier bytecode (this is just an example don't use in production)
-const bytecode = '0x608060405234801561001057600080fd5b5060d38061001f6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063cfae321714610046575b600080fd5b6100496100f1565b60405161005691906100f1565b60405180910390f35b'
-
-const result = await localEVMVerify(proofFileBuffer, bytecode)
-
-console.log('result', result)
-```
-
-**Note**: Run `ezkl create-evm-verifier` to get the Solidity verifier, with which you can retrieve the bytecode once compiled. We recommend compiling to the Shanghai hardfork target, else you will have to pass an additional parameter specifying the EVM version to the `localEVMVerify` function like so (for Paris hardfork):
-
-```ts
-import localEVMVerify, { hardfork } from '@ezkljs/verify';
-
-const result = await localEVMVerify(proofFileBuffer, bytecode, hardfork['Paris'])
-```
-
-**Note**: You can also verify separated vk verifiers using the `localEVMVerify` function. Just pass the vk verifier bytecode as the third parameter like so:
-```ts
-import localEVMVerify from '@ezkljs/verify';
-
-const result = await localEVMVerify(proofFileBuffer, verifierBytecode, VKBytecode)
-```
-
-
-## How to use (Browser)
-
-```ts
-import localEVMVerify from '@ezkljs/verify';
-
-// Load in the proof file as a buffer using the web apis (fetch, FileReader, etc)
-// We use fetch in this example to load the proof file as a buffer
-const proofFileBuffer = await fetch(`${path}/${example}/proof.pf`).then(res => res.arrayBuffer())
-
-// Stringified EZKL evm verifier bytecode (this is just an example don't use in production)
-const bytecode = '0x608060405234801561001057600080fd5b5060d38061001f6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063cfae321714610046575b600080fd5b6100496100f1565b60405161005691906100f1565b60405180910390f35b'
-
-const result = await browserEVMVerify(proofFileBuffer, bytecode)
-
-console.log('result', result)
-```
-
-Output:
-
-```ts  
-result: true
-```
-
-

in-browser-evm-verifier/package.json

@@ -1,42 +0,0 @@
-{
-  "name": "@ezkljs/verify",
-  "version": "0.0.0",
-  "publishConfig": {
-    "access": "public"
-  },
-  "description": "Evm verify EZKL proofs in the browser.",
-  "main": "dist/commonjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/commonjs/index.d.ts",
-  "files": [
-    "dist",
-    "LICENSE",
-    "README.md"
-  ],
-  "scripts": {
-    "clean": "rm -r dist || true",
-    "build:commonjs": "tsc --project tsconfig.commonjs.json && resolve-tspaths -p tsconfig.commonjs.json",
-    "build:esm": "tsc --project tsconfig.esm.json && resolve-tspaths -p tsconfig.esm.json",
-    "build": "pnpm run clean && pnpm run build:commonjs && pnpm run build:esm"
-  },
-  "dependencies": {
-    "@ethereumjs/common": "^4.0.0",
-    "@ethereumjs/evm": "^2.0.0",
-    "@ethereumjs/statemanager": "^2.0.0",
-    "@ethereumjs/tx": "^5.0.0",
-    "@ethereumjs/util": "^9.0.0",
-    "@ethereumjs/vm": "^7.0.0",
-    "@ethersproject/abi": "^5.7.0",
-    "@ezkljs/engine": "^9.4.4",
-    "ethers": "^6.7.1",
-    "json-bigint": "^1.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.8.3",
-    "ts-loader": "^9.5.0",
-    "ts-node": "^10.9.1",
-    "resolve-tspaths": "^0.8.16",
-    "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.2.2"
-  }
-}

in-browser-evm-verifier/src/index.ts

@@ -1,145 +0,0 @@
-import { defaultAbiCoder as AbiCoder } from '@ethersproject/abi'
-import { Address, hexToBytes } from '@ethereumjs/util'
-import { Chain, Common, Hardfork } from '@ethereumjs/common'
-import { LegacyTransaction, LegacyTxData } from '@ethereumjs/tx'
-// import { DefaultStateManager } from '@ethereumjs/statemanager'
-// import { Blockchain } from '@ethereumjs/blockchain'
-import { VM } from '@ethereumjs/vm'
-import { EVM } from '@ethereumjs/evm'
-import { buildTransaction, encodeDeployment } from './utils/tx-builder'
-import { getAccountNonce, insertAccount } from './utils/account-utils'
-import { encodeVerifierCalldata } from '../nodejs/ezkl';
-import { error } from 'console'
-
-async function deployContract(
-  vm: VM,
-  common: Common,
-  senderPrivateKey: Uint8Array,
-  deploymentBytecode: string
-): Promise<Address> {
-  // Contracts are deployed by sending their deployment bytecode to the address 0
-  // The contract params should be abi-encoded and appended to the deployment bytecode.
-  // const data =
-  const data = encodeDeployment(deploymentBytecode)
-  const txData = {
-    data,
-    nonce: await getAccountNonce(vm, senderPrivateKey),
-  }
-
-  const tx = LegacyTransaction.fromTxData(
-    buildTransaction(txData) as LegacyTxData,
-    { common, allowUnlimitedInitCodeSize: true },
-  ).sign(senderPrivateKey)
-
-  const deploymentResult = await vm.runTx({
-    tx,
-    skipBlockGasLimitValidation: true,
-    skipNonce: true
-  })
-
-  if (deploymentResult.execResult.exceptionError) {
-    throw deploymentResult.execResult.exceptionError
-  }
-
-  return deploymentResult.createdAddress!
-}
-
-async function verify(
-  vm: VM,
-  contractAddress: Address,
-  caller: Address,
-  proof: Uint8Array | Uint8ClampedArray,
-  vkAddress?: Address | Uint8Array,
-): Promise<boolean> {
-  if (proof instanceof Uint8Array) {
-    proof = new Uint8ClampedArray(proof.buffer)
-  }
-  if (vkAddress) {
-    const vkAddressBytes = hexToBytes(vkAddress.toString())
-    const vkAddressArray = Array.from(vkAddressBytes)
-
-    let string = JSON.stringify(vkAddressArray)
-
-    const uint8Array = new TextEncoder().encode(string);
-
-    // Step 3: Convert to Uint8ClampedArray
-    vkAddress = new Uint8Array(uint8Array.buffer);
-
-    // convert uitn8array of length
-    error('vkAddress', vkAddress)
-  }
-  const data = encodeVerifierCalldata(proof, vkAddress)
-
-  const verifyResult = await vm.evm.runCall({
-    to: contractAddress,
-    caller: caller,
-    origin: caller, // The tx.origin is also the caller here
-    data: data,
-  })
-
-  if (verifyResult.execResult.exceptionError) {
-    throw verifyResult.execResult.exceptionError
-  }
-
-  const results = AbiCoder.decode(['bool'], verifyResult.execResult.returnValue)
-
-  return results[0]
-}
-
-/**
- * Spins up an ephemeral EVM instance for executing the bytecode of a solidity verifier
- * @param proof Json serialized proof file
- * @param bytecode The bytecode of a compiled solidity verifier.
- * @param bytecode_vk The bytecode of a contract that stores the vk. (Optional, only required if the vk is stored in a separate contract)
- * @param evmVersion The evm version to use for the verification. (Default: London)
- * @returns The result of the evm verification.
- * @throws If the verify transaction reverts
- */
-export default async function localEVMVerify(
-  proof: Uint8Array | Uint8ClampedArray,
-  bytecode_verifier: string,
-  bytecode_vk?: string,
-  evmVersion?: Hardfork,
-): Promise<boolean> {
-  try {
-    const hardfork = evmVersion ? evmVersion : Hardfork['Shanghai']
-    const common = new Common({ chain: Chain.Mainnet, hardfork })
-    const accountPk = hexToBytes(
-      '0xe331b6d69882b4cb4ea581d88e0b604039a3de5967688d3dcffdd2270c0fd109', // anvil deterministic Pk 
-    )
-
-    const evm = new EVM({
-      allowUnlimitedContractSize: true,
-      allowUnlimitedInitCodeSize: true,
-    })
-
-    const vm = await VM.create({ common, evm })
-    const accountAddress = Address.fromPrivateKey(accountPk)
-
-    await insertAccount(vm, accountAddress)
-
-    const verifierAddress = await deployContract(
-      vm,
-      common,
-      accountPk,
-      bytecode_verifier
-    )
-
-    if (bytecode_vk) {
-      const accountPk = hexToBytes("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"); // anvil deterministic Pk
-      const accountAddress = Address.fromPrivateKey(accountPk)
-      await insertAccount(vm, accountAddress)
-      const output = await deployContract(vm, common, accountPk, bytecode_vk)
-      const result = await verify(vm, verifierAddress, accountAddress, proof, output)
-      return true
-    }
-
-    const result = await verify(vm, verifierAddress, accountAddress, proof)
-
-    return result
-  } catch (error) {
-    // log or re-throw the error, depending on your needs
-    console.error('An error occurred:', error)
-    throw error
-  }
-}

in-browser-evm-verifier/src/utils/account-utils.ts

@@ -1,32 +0,0 @@
-import { VM } from '@ethereumjs/vm'
-import { Account, Address } from '@ethereumjs/util'
-
-export const keyPair = {
-  secretKey:
-    '0x3cd7232cd6f3fc66a57a6bedc1a8ed6c228fff0a327e169c2bcc5e869ed49511',
-  publicKey:
-    '0x0406cc661590d48ee972944b35ad13ff03c7876eae3fd191e8a2f77311b0a3c6613407b5005e63d7d8d76b89d5f900cde691497688bb281e07a5052ff61edebdc0',
-}
-
-export const insertAccount = async (vm: VM, address: Address) => {
-  const acctData = {
-    nonce: 0,
-    balance: BigInt('1000000000000000000'), // 1 eth
-  }
-  const account = Account.fromAccountData(acctData)
-
-  await vm.stateManager.putAccount(address, account)
-}
-
-export const getAccountNonce = async (
-  vm: VM,
-  accountPrivateKey: Uint8Array,
-) => {
-  const address = Address.fromPrivateKey(accountPrivateKey)
-  const account = await vm.stateManager.getAccount(address)
-  if (account) {
-    return account.nonce
-  } else {
-    return BigInt(0)
-  }
-}

in-browser-evm-verifier/src/utils/tx-builder.ts

@@ -1,59 +0,0 @@
-import { Interface, defaultAbiCoder as AbiCoder } from '@ethersproject/abi'
-import {
-  AccessListEIP2930TxData,
-  FeeMarketEIP1559TxData,
-  TxData,
-} from '@ethereumjs/tx'
-
-type TransactionsData =
-  | TxData
-  | AccessListEIP2930TxData
-  | FeeMarketEIP1559TxData
-
-export const encodeFunction = (
-  method: string,
-  params?: {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    types: any[]
-    values: unknown[]
-  },
-): string => {
-  const parameters = params?.types ?? []
-  const methodWithParameters = `function ${method}(${parameters.join(',')})`
-  const signatureHash = new Interface([methodWithParameters]).getSighash(method)
-  const encodedArgs = AbiCoder.encode(parameters, params?.values ?? [])
-
-  return signatureHash + encodedArgs.slice(2)
-}
-
-export const encodeDeployment = (
-  bytecode: string,
-  params?: {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    types: any[]
-    values: unknown[]
-  },
-) => {
-  const deploymentData = '0x' + bytecode
-  if (params) {
-    const argumentsEncoded = AbiCoder.encode(params.types, params.values)
-    return deploymentData + argumentsEncoded.slice(2)
-  }
-  return deploymentData
-}
-
-export const buildTransaction = (
-  data: Partial<TransactionsData>,
-): TransactionsData => {
-  const defaultData: Partial<TransactionsData> = {
-    gasLimit: 3_000_000_000_000_000,
-    gasPrice: 7,
-    value: 0,
-    data: '0x',
-  }
-
-  return {
-    ...defaultData,
-    ...data,
-  }
-}

in-browser-evm-verifier/tsconfig.commonjs.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "CommonJS",
-    "outDir": "./dist/commonjs"
-  }
-}

in-browser-evm-verifier/tsconfig.esm.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "ES2020",
-    "outDir": "./dist/esm"
-  }
-}

in-browser-evm-verifier/tsconfig.json

@@ -1,62 +0,0 @@
-{
-  "compilerOptions": {
-    "rootDir": "src",
-    "target": "es2017",
-    "outDir": "dist",
-    "declaration": true,
-    "lib": [
-      "dom",
-      "dom.iterable",
-      "esnext"
-    ],
-    "allowJs": true,
-    "checkJs": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "noEmit": false,
-    "esModuleInterop": true,
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "jsx": "preserve",
-    // "incremental": true,
-    "noUncheckedIndexedAccess": true,
-    "baseUrl": ".",
-    "paths": {
-      "@/*": [
-        "./src/*"
-      ]
-    }
-  },
-  "include": [
-    "src/**/*.ts",
-    "src/**/*.tsx",
-    "src/**/*.cjs",
-    "src/**/*.mjs"
-  ],
-  "exclude": [
-    "node_modules"
-  ],
-  // NEW: Options for file/directory watching
-  "watchOptions": {
-    // Use native file system events for files and directories
-    "watchFile": "useFsEvents",
-    "watchDirectory": "useFsEvents",
-    // Poll files for updates more frequently
-    // when they're updated a lot.
-    "fallbackPolling": "dynamicPriority",
-    // Don't coalesce watch notification
-    "synchronousWatchDirectory": true,
-    // Finally, two additional settings for reducing the amount of possible
-    // files to track  work from these directories
-    "excludeDirectories": [
-      "**/node_modules",
-      "_build"
-    ],
-    "excludeFiles": [
-      "build/fileWhichChangesOften.ts"
-    ]
-  }
-}

package.json

@@ -7,7 +7,7 @@
     "test": "jest"
   },
   "devDependencies": {
-    "@ezkljs/engine": "^9.4.4",
+    "@ezkljs/engine": "^2.4.5",
     "@ezkljs/verify": "^0.0.6",
     "@jest/types": "^29.6.3",
     "@types/file-saver": "^2.0.5",
@@ -27,4 +27,4 @@
     "tsconfig-paths": "^4.2.0",
     "typescript": "5.1.6"
   }
-}
+}

pnpm-lock.yaml

@@ -6,8 +6,8 @@ settings:
 
 devDependencies:
   '@ezkljs/engine':
-    specifier: ^9.4.4
-    version: 9.4.4
+    specifier: ^2.4.5
+    version: 2.4.5
   '@ezkljs/verify':
     specifier: ^0.0.6
     version: 0.0.6(buffer@6.0.3)
@@ -785,13 +785,6 @@ packages:
       json-bigint: 1.0.0
     dev: true
 
-  /@ezkljs/engine@9.4.4:
-    resolution: {integrity: sha512-kNsTmDQa8mIiQ6yjJmBMwVgAAxh4nfs4NCtnewJifonyA8Mfhs+teXwwW8WhERRDoQPUofKO2pT8BPvV/XGIDA==}
-    dependencies:
-      '@types/json-bigint': 1.0.1
-      json-bigint: 1.0.0
-    dev: true
-
   /@ezkljs/verify@0.0.6(buffer@6.0.3):
     resolution: {integrity: sha512-9DHoEhLKl1DBGuUVseXLThuMyYceY08Zymr/OsLH0zbdA9OoISYhb77j4QPm4ANRKEm5dCi8oHDqkwGbFc2xFQ==}
     dependencies:

src/bin/ezkl.rs

@@ -11,8 +11,8 @@ use ezkl::execute::run;
 #[cfg(not(target_arch = "wasm32"))]
 use ezkl::logger::init_logger;
 #[cfg(not(target_arch = "wasm32"))]
-use log::{debug, error, info};
-#[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
+use log::{error, info};
+#[cfg(not(target_arch = "wasm32"))]
 use rand::prelude::SliceRandom;
 #[cfg(not(target_arch = "wasm32"))]
 #[cfg(feature = "icicle")]
@@ -25,7 +25,6 @@ use std::error::Error;
 pub async fn main() -> Result<(), Box<dyn Error>> {
     let args = Cli::parse();
     init_logger();
-    #[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
     banner();
     #[cfg(feature = "icicle")]
     if env::var("ENABLE_ICICLE_GPU").is_ok() {
@@ -33,7 +32,7 @@ pub async fn main() -> Result<(), Box<dyn Error>> {
     } else {
         info!("Running with CPU");
     }
-    debug!("command: \n {}", &args.as_json()?.to_colored_json_auto()?);
+    info!("command: \n {}", &args.as_json()?.to_colored_json_auto()?);
     let res = run(args.command).await;
     match &res {
         Ok(_) => info!("succeeded"),
@@ -45,7 +44,7 @@ pub async fn main() -> Result<(), Box<dyn Error>> {
 #[cfg(target_arch = "wasm32")]
 pub fn main() {}
 
-#[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
+#[cfg(not(target_arch = "wasm32"))]
 fn banner() {
     let ell: Vec<&str> = vec![
         "for Neural Networks",

src/circuit/modules/kzg.rs

@@ -41,7 +41,7 @@ pub struct KZGChip {
 }
 
 impl KZGChip {
-    /// Commit to the message using the KZG commitment scheme
+    /// Returns the number of inputs to the hash function
     pub fn commit(
         message: Vec<Fp>,
         degree: u32,

src/circuit/modules/planner.rs

@@ -15,7 +15,7 @@ use halo2_proofs::{
         Instance, Selector, TableColumn,
     },
 };
-use log::{debug, trace};
+use log::{trace, warn};
 
 /// A simple [`FloorPlanner`] that performs minimal optimizations.
 #[derive(Debug)]
@@ -119,7 +119,7 @@ impl<'a, F: Field, CS: Assignment<F> + 'a + SyncDeps> Layouter<F> for ModuleLayo
                 Error::Synthesis
             })?;
             if !self.regions.contains_key(&index) {
-                debug!("spawning module {}", index)
+                warn!("spawning module {}", index)
             };
             self.current_module = index;
         }

src/circuit/ops/base.rs

@@ -12,11 +12,15 @@ pub enum BaseOp {
     DotInit,
     CumProdInit,
     CumProd,
+    Identity,
     Add,
     Mult,
     Sub,
     SumInit,
     Sum,
+    Neg,
+    Range { tol: i32 },
+    IsZero,
     IsBoolean,
 }
 
@@ -32,8 +36,12 @@ impl BaseOp {
         let (a, b) = inputs;
         match &self {
             BaseOp::Add => a + b,
+            BaseOp::Identity => b,
+            BaseOp::Neg => -b,
             BaseOp::Sub => a - b,
             BaseOp::Mult => a * b,
+            BaseOp::Range { .. } => b,
+            BaseOp::IsZero => b,
             BaseOp::IsBoolean => b,
             _ => panic!("nonaccum_f called on accumulating operation"),
         }
@@ -65,15 +73,19 @@ impl BaseOp {
     /// display func
     pub fn as_str(&self) -> &'static str {
         match self {
+            BaseOp::Identity => "IDENTITY",
             BaseOp::Dot => "DOT",
             BaseOp::DotInit => "DOTINIT",
             BaseOp::CumProdInit => "CUMPRODINIT",
             BaseOp::CumProd => "CUMPROD",
             BaseOp::Add => "ADD",
+            BaseOp::Neg => "NEG",
             BaseOp::Sub => "SUB",
             BaseOp::Mult => "MULT",
             BaseOp::Sum => "SUM",
             BaseOp::SumInit => "SUMINIT",
+            BaseOp::Range { .. } => "RANGE",
+            BaseOp::IsZero => "ISZERO",
             BaseOp::IsBoolean => "ISBOOLEAN",
         }
     }
@@ -81,6 +93,8 @@ impl BaseOp {
     /// Returns the range of the query offset for this operation.
     pub fn query_offset_rng(&self) -> (i32, usize) {
         match self {
+            BaseOp::Identity => (0, 1),
+            BaseOp::Neg => (0, 1),
             BaseOp::DotInit => (0, 1),
             BaseOp::Dot => (-1, 2),
             BaseOp::CumProd => (-1, 2),
@@ -90,6 +104,8 @@ impl BaseOp {
             BaseOp::Mult => (0, 1),
             BaseOp::Sum => (-1, 2),
             BaseOp::SumInit => (0, 1),
+            BaseOp::Range { .. } => (0, 1),
+            BaseOp::IsZero => (0, 1),
             BaseOp::IsBoolean => (0, 1),
         }
     }
@@ -97,6 +113,8 @@ impl BaseOp {
     /// Returns the number of inputs for this operation.
     pub fn num_inputs(&self) -> usize {
         match self {
+            BaseOp::Identity => 1,
+            BaseOp::Neg => 1,
             BaseOp::DotInit => 2,
             BaseOp::Dot => 2,
             BaseOp::CumProdInit => 1,
@@ -106,22 +124,28 @@ impl BaseOp {
             BaseOp::Mult => 2,
             BaseOp::Sum => 1,
             BaseOp::SumInit => 1,
-            BaseOp::IsBoolean => 0,
+            BaseOp::Range { .. } => 1,
+            BaseOp::IsZero => 1,
+            BaseOp::IsBoolean => 1,
         }
     }
 
     /// Returns the number of outputs for this operation.
     pub fn constraint_idx(&self) -> usize {
         match self {
+            BaseOp::Identity => 0,
+            BaseOp::Neg => 0,
             BaseOp::DotInit => 0,
             BaseOp::Dot => 1,
             BaseOp::Add => 0,
             BaseOp::Sub => 0,
             BaseOp::Mult => 0,
+            BaseOp::Range { .. } => 0,
             BaseOp::Sum => 1,
             BaseOp::SumInit => 0,
             BaseOp::CumProd => 1,
             BaseOp::CumProdInit => 0,
+            BaseOp::IsZero => 0,
             BaseOp::IsBoolean => 0,
         }
     }

src/circuit/ops/chip.rs

@@ -16,11 +16,10 @@ use pyo3::{
     types::PyString,
 };
 use serde::{Deserialize, Serialize};
-use tosubcommand::ToFlags;
 
 use crate::{
+    circuit::ops::base::BaseOp,
     circuit::{
-        ops::base::BaseOp,
         table::{Range, RangeCheck, Table},
         utils,
     },
@@ -62,22 +61,6 @@ pub enum CheckMode {
     UNSAFE,
 }
 
-impl std::fmt::Display for CheckMode {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            CheckMode::SAFE => write!(f, "safe"),
-            CheckMode::UNSAFE => write!(f, "unsafe"),
-        }
-    }
-}
-
-impl ToFlags for CheckMode {
-    /// Convert the struct to a subcommand string
-    fn to_flags(&self) -> Vec<String> {
-        vec![format!("{}", self)]
-    }
-}
-
 impl From<String> for CheckMode {
     fn from(value: String) -> Self {
         match value.to_lowercase().as_str() {
@@ -100,19 +83,6 @@ pub struct Tolerance {
     pub scale: utils::F32,
 }
 
-impl std::fmt::Display for Tolerance {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:.2}", self.val)
-    }
-}
-
-impl ToFlags for Tolerance {
-    /// Convert the struct to a subcommand string
-    fn to_flags(&self) -> Vec<String> {
-        vec![format!("{}", self)]
-    }
-}
-
 impl FromStr for Tolerance {
     type Err = String;
 
@@ -188,158 +158,31 @@ impl<'source> FromPyObject<'source> for Tolerance {
     }
 }
 
-/// A struct representing the selectors for the dynamic lookup tables
-#[derive(Clone, Debug, Default)]
-pub struct DynamicLookups {
-    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many dynamic lookup ops.
-    pub lookup_selectors: BTreeMap<(usize, usize), Selector>,
-    /// Selectors for the dynamic lookup tables
-    pub table_selectors: Vec<Selector>,
-    /// Inputs:
-    pub inputs: Vec<VarTensor>,
-    /// tables
-    pub tables: Vec<VarTensor>,
-}
-
-impl DynamicLookups {
-    /// Returns a new [DynamicLookups] with no inputs, no selectors, and no tables.
-    pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
-        let dummy_var = VarTensor::dummy(col_size, num_inner_cols);
-        let single_col_dummy_var = VarTensor::dummy(col_size, 1);
-
-        Self {
-            lookup_selectors: BTreeMap::new(),
-            table_selectors: vec![],
-            inputs: vec![dummy_var.clone(), dummy_var.clone(), dummy_var.clone()],
-            tables: vec![
-                single_col_dummy_var.clone(),
-                single_col_dummy_var.clone(),
-                single_col_dummy_var.clone(),
-            ],
-        }
-    }
-}
-
-/// A struct representing the selectors for the dynamic lookup tables
-#[derive(Clone, Debug, Default)]
-pub struct Shuffles {
-    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many dynamic lookup ops.
-    pub input_selectors: BTreeMap<(usize, usize), Selector>,
-    /// Selectors for the dynamic lookup tables
-    pub reference_selectors: Vec<Selector>,
-    /// Inputs:
-    pub inputs: Vec<VarTensor>,
-    /// tables
-    pub references: Vec<VarTensor>,
-}
-
-impl Shuffles {
-    /// Returns a new [DynamicLookups] with no inputs, no selectors, and no tables.
-    pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
-        let dummy_var = VarTensor::dummy(col_size, num_inner_cols);
-        let single_col_dummy_var = VarTensor::dummy(col_size, 1);
-
-        Self {
-            input_selectors: BTreeMap::new(),
-            reference_selectors: vec![],
-            inputs: vec![dummy_var.clone(), dummy_var.clone()],
-            references: vec![single_col_dummy_var.clone(), single_col_dummy_var.clone()],
-        }
-    }
-}
-
-/// A struct representing the selectors for the static lookup tables
-#[derive(Clone, Debug, Default)]
-pub struct StaticLookups<F: PrimeField + TensorType + PartialOrd> {
-    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many dynamic lookup ops.
-    pub selectors: BTreeMap<(LookupOp, usize, usize), Selector>,
-    /// Selectors for the dynamic lookup tables
-    pub tables: BTreeMap<LookupOp, Table<F>>,
-    ///
-    pub index: VarTensor,
-    ///
-    pub output: VarTensor,
-    ///
-    pub input: VarTensor,
-}
-
-impl<F: PrimeField + TensorType + PartialOrd> StaticLookups<F> {
-    /// Returns a new [StaticLookups] with no inputs, no selectors, and no tables.
-    pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
-        let dummy_var = VarTensor::dummy(col_size, num_inner_cols);
-
-        Self {
-            selectors: BTreeMap::new(),
-            tables: BTreeMap::new(),
-            index: dummy_var.clone(),
-            output: dummy_var.clone(),
-            input: dummy_var,
-        }
-    }
-}
-
-/// A struct representing the selectors for custom gates
-#[derive(Clone, Debug, Default)]
-pub struct CustomGates {
-    /// the inputs to the accumulated operations.
-    pub inputs: Vec<VarTensor>,
-    /// the (currently singular) output of the accumulated operations.
-    pub output: VarTensor,
-    /// selector
-    pub selectors: BTreeMap<(BaseOp, usize, usize), Selector>,
-}
-
-impl CustomGates {
-    /// Returns a new [CustomGates] with no inputs, no selectors, and no tables.
-    pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
-        let dummy_var = VarTensor::dummy(col_size, num_inner_cols);
-        Self {
-            inputs: vec![dummy_var.clone(), dummy_var.clone()],
-            output: dummy_var,
-            selectors: BTreeMap::new(),
-        }
-    }
-}
-
-/// A struct representing the selectors for the range checks
-#[derive(Clone, Debug, Default)]
-pub struct RangeChecks<F: PrimeField + TensorType + PartialOrd> {
-    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many dynamic lookup ops.
-    pub selectors: BTreeMap<(Range, usize, usize), Selector>,
-    /// Selectors for the dynamic lookup tables
-    pub ranges: BTreeMap<Range, RangeCheck<F>>,
-    ///
-    pub index: VarTensor,
-    ///
-    pub input: VarTensor,
-}
-
-impl<F: PrimeField + TensorType + PartialOrd> RangeChecks<F> {
-    /// Returns a new [RangeChecks] with no inputs, no selectors, and no tables.
-    pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
-        let dummy_var = VarTensor::dummy(col_size, num_inner_cols);
-        Self {
-            selectors: BTreeMap::new(),
-            ranges: BTreeMap::new(),
-            index: dummy_var.clone(),
-            input: dummy_var,
-        }
-    }
-}
-
 /// Configuration for an accumulated arg.
 #[derive(Clone, Debug, Default)]
 pub struct BaseConfig<F: PrimeField + TensorType + PartialOrd> {
-    /// Custom gates
-    pub custom_gates: CustomGates,
-    /// StaticLookups
-    pub static_lookups: StaticLookups<F>,
-    /// [Selector]s for the dynamic lookup tables
-    pub dynamic_lookups: DynamicLookups,
-    /// [Selector]s for the range checks
-    pub range_checks: RangeChecks<F>,
-    /// [Selector]s for the shuffles
-    pub shuffles: Shuffles,
+    /// the inputs to the accumulated operations.
+    pub inputs: Vec<VarTensor>,
+    /// the VarTensor reserved for lookup operations (could be an element of inputs)
+    /// Note that you should be careful to ensure that the lookup_input is not simultaneously assigned to by other non-lookup operations eg. in the case of composite ops.
+    pub lookup_input: VarTensor,
+    /// the (currently singular) output of the accumulated operations.
+    pub output: VarTensor,
+    /// the VarTensor reserved for lookup operations (could be an element of inputs or the same as output)
+    /// Note that you should be careful to ensure that the lookup_output is not simultaneously assigned to by other non-lookup operations eg. in the case of composite ops.
+    pub lookup_output: VarTensor,
+    ///
+    pub lookup_index: VarTensor,
+    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure [BaseOp].
+    pub selectors: BTreeMap<(BaseOp, usize, usize), Selector>,
+    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many lookup ops.
+    pub lookup_selectors: BTreeMap<(LookupOp, usize, usize), Selector>,
+    ///
+    pub tables: BTreeMap<LookupOp, Table<F>>,
+    ///
+    pub range_checks: BTreeMap<Range, RangeCheck<F>>,
+    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many lookup ops.
+    pub range_check_selectors: BTreeMap<(Range, usize, usize), Selector>,
     /// Activate sanity checks
     pub check_mode: CheckMode,
     _marker: PhantomData<F>,
@@ -348,12 +191,19 @@ pub struct BaseConfig<F: PrimeField + TensorType + PartialOrd> {
 impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
     /// Returns a new [BaseConfig] with no inputs, no selectors, and no tables.
     pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
+        let dummy_var = VarTensor::dummy(col_size, num_inner_cols);
+
         Self {
-            custom_gates: CustomGates::dummy(col_size, num_inner_cols),
-            static_lookups: StaticLookups::dummy(col_size, num_inner_cols),
-            dynamic_lookups: DynamicLookups::dummy(col_size, num_inner_cols),
-            shuffles: Shuffles::dummy(col_size, num_inner_cols),
-            range_checks: RangeChecks::dummy(col_size, num_inner_cols),
+            inputs: vec![dummy_var.clone(), dummy_var.clone()],
+            lookup_input: dummy_var.clone(),
+            output: dummy_var.clone(),
+            lookup_output: dummy_var.clone(),
+            lookup_index: dummy_var,
+            selectors: BTreeMap::new(),
+            lookup_selectors: BTreeMap::new(),
+            range_check_selectors: BTreeMap::new(),
+            tables: BTreeMap::new(),
+            range_checks: BTreeMap::new(),
             check_mode: CheckMode::SAFE,
             _marker: PhantomData,
         }
@@ -386,7 +236,10 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
             for j in 0..output.num_inner_cols() {
                 nonaccum_selectors.insert((BaseOp::Add, i, j), meta.selector());
                 nonaccum_selectors.insert((BaseOp::Sub, i, j), meta.selector());
+                nonaccum_selectors.insert((BaseOp::Neg, i, j), meta.selector());
                 nonaccum_selectors.insert((BaseOp::Mult, i, j), meta.selector());
+                nonaccum_selectors.insert((BaseOp::IsZero, i, j), meta.selector());
+                nonaccum_selectors.insert((BaseOp::Identity, i, j), meta.selector());
                 nonaccum_selectors.insert((BaseOp::IsBoolean, i, j), meta.selector());
             }
         }
@@ -423,14 +276,9 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
 
                 let constraints = match base_op {
                     BaseOp::IsBoolean => {
-                        let expected_output: Tensor<Expression<F>> = output
-                            .query_rng(meta, *block_idx, *inner_col_idx, 0, 1)
-                            .expect("non accum: output query failed");
-
-                        let output = expected_output[base_op.constraint_idx()].clone();
-
-                        vec![(output.clone()) * (output.clone() - Expression::Constant(F::from(1)))]
+                        vec![(qis[1].clone()) * (qis[1].clone() - Expression::Constant(F::from(1)))]
                     }
+                    BaseOp::IsZero => vec![qis[1].clone()],
                     _ => {
                         let expected_output: Tensor<Expression<F>> = output
                             .query_rng(meta, *block_idx, *inner_col_idx, rotation_offset, rng)
@@ -484,15 +332,16 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
             .collect();
 
         Self {
-            custom_gates: CustomGates {
-                inputs: inputs.to_vec(),
-                output: output.clone(),
-                selectors,
-            },
-            static_lookups: StaticLookups::default(),
-            dynamic_lookups: DynamicLookups::default(),
-            shuffles: Shuffles::default(),
-            range_checks: RangeChecks::default(),
+            selectors,
+            lookup_selectors: BTreeMap::new(),
+            range_check_selectors: BTreeMap::new(),
+            inputs: inputs.to_vec(),
+            lookup_input: VarTensor::Empty,
+            lookup_output: VarTensor::Empty,
+            lookup_index: VarTensor::Empty,
+            tables: BTreeMap::new(),
+            range_checks: BTreeMap::new(),
+            output: output.clone(),
             check_mode,
             _marker: PhantomData,
         }
@@ -513,6 +362,8 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
     where
         F: Field,
     {
+        let mut selectors = BTreeMap::new();
+
         if !index.is_advice() {
             return Err("wrong input type for lookup index".into());
         }
@@ -525,9 +376,9 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
 
         // we borrow mutably twice so we need to do this dance
 
-        let table = if !self.static_lookups.tables.contains_key(nl) {
+        let table = if !self.tables.contains_key(nl) {
             // as all tables have the same input we see if there's another table who's input we can reuse
-            let table = if let Some(table) = self.static_lookups.tables.values().next() {
+            let table = if let Some(table) = self.tables.values().next() {
                 Table::<F>::configure(
                     cs,
                     lookup_range,
@@ -538,7 +389,7 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
             } else {
                 Table::<F>::configure(cs, lookup_range, logrows, nl, None)
             };
-            self.static_lookups.tables.insert(nl.clone(), table.clone());
+            self.tables.insert(nl.clone(), table.clone());
             table
         } else {
             return Ok(());
@@ -622,218 +473,49 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
                         res
                     });
                 }
-                self.static_lookups
-                    .selectors
-                    .insert((nl.clone(), x, y), multi_col_selector);
+                selectors.insert((nl.clone(), x, y), multi_col_selector);
             }
         }
+        self.lookup_selectors.extend(selectors);
         // if we haven't previously initialized the input/output, do so now
-        if let VarTensor::Empty = self.static_lookups.input {
+        if let VarTensor::Empty = self.lookup_input {
             debug!("assigning lookup input");
-            self.static_lookups.input = input.clone();
+            self.lookup_input = input.clone();
         }
-        if let VarTensor::Empty = self.static_lookups.output {
+        if let VarTensor::Empty = self.lookup_output {
             debug!("assigning lookup output");
-            self.static_lookups.output = output.clone();
+            self.lookup_output = output.clone();
         }
-        if let VarTensor::Empty = self.static_lookups.index {
+        if let VarTensor::Empty = self.lookup_index {
             debug!("assigning lookup index");
-            self.static_lookups.index = index.clone();
+            self.lookup_index = index.clone();
         }
         Ok(())
     }
 
-    /// Configures and creates lookup selectors
-    #[allow(clippy::too_many_arguments)]
-    pub fn configure_dynamic_lookup(
-        &mut self,
-        cs: &mut ConstraintSystem<F>,
-        lookups: &[VarTensor; 3],
-        tables: &[VarTensor; 3],
-    ) -> Result<(), Box<dyn Error>>
-    where
-        F: Field,
-    {
-        for l in lookups.iter() {
-            if !l.is_advice() {
-                return Err("wrong input type for dynamic lookup".into());
-            }
-        }
-
-        for t in tables.iter() {
-            if !t.is_advice() || t.num_blocks() > 1 || t.num_inner_cols() > 1 {
-                return Err("wrong table type for dynamic lookup".into());
-            }
-        }
-
-        let one = Expression::Constant(F::ONE);
-
-        let s_ltable = cs.complex_selector();
-
-        for x in 0..lookups[0].num_blocks() {
-            for y in 0..lookups[0].num_inner_cols() {
-                let s_lookup = cs.complex_selector();
-
-                cs.lookup_any("lookup", |cs| {
-                    let s_lookupq = cs.query_selector(s_lookup);
-                    let mut expression = vec![];
-                    let s_ltableq = cs.query_selector(s_ltable);
-                    let mut lookup_queries = vec![one.clone()];
-
-                    for lookup in lookups {
-                        lookup_queries.push(match lookup {
-                            VarTensor::Advice { inner: advices, .. } => {
-                                cs.query_advice(advices[x][y], Rotation(0))
-                            }
-                            _ => unreachable!(),
-                        });
-                    }
-
-                    let mut table_queries = vec![one.clone()];
-                    for table in tables {
-                        table_queries.push(match table {
-                            VarTensor::Advice { inner: advices, .. } => {
-                                cs.query_advice(advices[0][0], Rotation(0))
-                            }
-                            _ => unreachable!(),
-                        });
-                    }
-
-                    let lhs = lookup_queries.into_iter().map(|c| c * s_lookupq.clone());
-                    let rhs = table_queries.into_iter().map(|c| c * s_ltableq.clone());
-                    expression.extend(lhs.zip(rhs));
-
-                    expression
-                });
-                self.dynamic_lookups
-                    .lookup_selectors
-                    .entry((x, y))
-                    .or_insert(s_lookup);
-            }
-        }
-        self.dynamic_lookups.table_selectors.push(s_ltable);
-
-        // if we haven't previously initialized the input/output, do so now
-        if self.dynamic_lookups.tables.is_empty() {
-            debug!("assigning dynamic lookup table");
-            self.dynamic_lookups.tables = tables.to_vec();
-        }
-        if self.dynamic_lookups.inputs.is_empty() {
-            debug!("assigning dynamic lookup input");
-            self.dynamic_lookups.inputs = lookups.to_vec();
-        }
-
-        Ok(())
-    }
-
-    /// Configures and creates lookup selectors
-    #[allow(clippy::too_many_arguments)]
-    pub fn configure_shuffles(
-        &mut self,
-        cs: &mut ConstraintSystem<F>,
-        inputs: &[VarTensor; 2],
-        references: &[VarTensor; 2],
-    ) -> Result<(), Box<dyn Error>>
-    where
-        F: Field,
-    {
-        for l in inputs.iter() {
-            if !l.is_advice() {
-                return Err("wrong input type for dynamic lookup".into());
-            }
-        }
-
-        for t in references.iter() {
-            if !t.is_advice() || t.num_blocks() > 1 || t.num_inner_cols() > 1 {
-                return Err("wrong table type for dynamic lookup".into());
-            }
-        }
-
-        let one = Expression::Constant(F::ONE);
-
-        let s_reference = cs.complex_selector();
-
-        for x in 0..inputs[0].num_blocks() {
-            for y in 0..inputs[0].num_inner_cols() {
-                let s_input = cs.complex_selector();
-
-                cs.lookup_any("lookup", |cs| {
-                    let s_inputq = cs.query_selector(s_input);
-                    let mut expression = vec![];
-                    let s_referenceq = cs.query_selector(s_reference);
-                    let mut input_queries = vec![one.clone()];
-
-                    for input in inputs {
-                        input_queries.push(match input {
-                            VarTensor::Advice { inner: advices, .. } => {
-                                cs.query_advice(advices[x][y], Rotation(0))
-                            }
-                            _ => unreachable!(),
-                        });
-                    }
-
-                    let mut ref_queries = vec![one.clone()];
-                    for reference in references {
-                        ref_queries.push(match reference {
-                            VarTensor::Advice { inner: advices, .. } => {
-                                cs.query_advice(advices[0][0], Rotation(0))
-                            }
-                            _ => unreachable!(),
-                        });
-                    }
-
-                    let lhs = input_queries.into_iter().map(|c| c * s_inputq.clone());
-                    let rhs = ref_queries.into_iter().map(|c| c * s_referenceq.clone());
-                    expression.extend(lhs.zip(rhs));
-
-                    expression
-                });
-                self.shuffles
-                    .input_selectors
-                    .entry((x, y))
-                    .or_insert(s_input);
-            }
-        }
-        self.shuffles.reference_selectors.push(s_reference);
-
-        // if we haven't previously initialized the input/output, do so now
-        if self.shuffles.references.is_empty() {
-            debug!("assigning shuffles reference");
-            self.shuffles.references = references.to_vec();
-        }
-        if self.shuffles.inputs.is_empty() {
-            debug!("assigning shuffles input");
-            self.shuffles.inputs = inputs.to_vec();
-        }
-
-        Ok(())
-    }
-
     /// Configures and creates lookup selectors
     #[allow(clippy::too_many_arguments)]
     pub fn configure_range_check(
         &mut self,
         cs: &mut ConstraintSystem<F>,
         input: &VarTensor,
-        index: &VarTensor,
         range: Range,
-        logrows: usize,
     ) -> Result<(), Box<dyn Error>>
     where
         F: Field,
     {
+        let mut selectors = BTreeMap::new();
+
         if !input.is_advice() {
             return Err("wrong input type for lookup input".into());
         }
 
         // we borrow mutably twice so we need to do this dance
 
-        let range_check = if let std::collections::btree_map::Entry::Vacant(e) =
-            self.range_checks.ranges.entry(range)
-        {
+        let range_check = if !self.range_checks.contains_key(&range) {
             // as all tables have the same input we see if there's another table who's input we can reuse
-            let range_check = RangeCheck::<F>::configure(cs, range, logrows);
-            e.insert(range_check.clone());
+            let range_check = RangeCheck::<F>::configure(cs, range);
+            self.range_checks.insert(range, range_check.clone());
             range_check
         } else {
             return Ok(());
@@ -841,73 +523,39 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
 
         for x in 0..input.num_blocks() {
             for y in 0..input.num_inner_cols() {
-                let len = range_check.selector_constructor.degree;
-                let multi_col_selector = cs.complex_selector();
+                let single_col_sel = cs.complex_selector();
 
-                for (col_idx, input_col) in range_check.inputs.iter().enumerate() {
-                    cs.lookup("", |cs| {
-                        let mut res = vec![];
-                        let sel = cs.query_selector(multi_col_selector);
+                cs.lookup("", |cs| {
+                    let mut res = vec![];
+                    let sel = cs.query_selector(single_col_sel);
 
-                        let synthetic_sel = match len {
-                            1 => Expression::Constant(F::from(1)),
-                            _ => match index {
-                                VarTensor::Advice { inner: advices, .. } => {
-                                    cs.query_advice(advices[x][y], Rotation(0))
-                                }
-                                _ => unreachable!(),
-                            },
-                        };
+                    let input_query = match &input {
+                        VarTensor::Advice { inner: advices, .. } => {
+                            cs.query_advice(advices[x][y], Rotation(0))
+                        }
+                        _ => unreachable!(),
+                    };
 
-                        let input_query = match &input {
-                            VarTensor::Advice { inner: advices, .. } => {
-                                cs.query_advice(advices[x][y], Rotation(0))
-                            }
-                            _ => unreachable!(),
-                        };
+                    let default_x = range_check.get_first_element();
 
-                        let default_x = range_check.get_first_element(col_idx);
+                    let not_sel = Expression::Constant(F::ONE) - sel.clone();
 
-                        let col_expr = sel.clone()
-                            * range_check
-                                .selector_constructor
-                                .get_expr_at_idx(col_idx, synthetic_sel);
+                    res.extend([(
+                        sel.clone() * input_query.clone()
+                            + not_sel.clone() * Expression::Constant(default_x),
+                        range_check.input,
+                    )]);
 
-                        let multiplier = range_check
-                            .selector_constructor
-                            .get_selector_val_at_idx(col_idx);
-
-                        let not_expr = Expression::Constant(multiplier) - col_expr.clone();
-
-                        res.extend([(
-                            col_expr.clone() * input_query.clone()
-                                + not_expr.clone() * Expression::Constant(default_x),
-                            *input_col,
-                        )]);
-
-                        log::trace!("---------------- col {:?} ------------------", col_idx,);
-                        log::trace!("expr: {:?}", col_expr,);
-                        log::trace!("multiplier: {:?}", multiplier);
-                        log::trace!("not_expr: {:?}", not_expr);
-                        log::trace!("default x: {:?}", default_x);
-
-                        res
-                    });
-                }
-                self.range_checks
-                    .selectors
-                    .insert((range, x, y), multi_col_selector);
+                    res
+                });
+                selectors.insert((range, x, y), single_col_sel);
             }
         }
+        self.range_check_selectors.extend(selectors);
         // if we haven't previously initialized the input/output, do so now
-        if let VarTensor::Empty = self.range_checks.input {
-            debug!("assigning range check input");
-            self.range_checks.input = input.clone();
-        }
-
-        if let VarTensor::Empty = self.range_checks.index {
-            debug!("assigning range check index");
-            self.range_checks.index = index.clone();
+        if let VarTensor::Empty = self.lookup_input {
+            debug!("assigning lookup input");
+            self.lookup_input = input.clone();
         }
 
         Ok(())
@@ -915,7 +563,7 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
 
     /// layout_tables must be called before layout.
     pub fn layout_tables(&mut self, layouter: &mut impl Layouter<F>) -> Result<(), Box<dyn Error>> {
-        for (i, table) in self.static_lookups.tables.values_mut().enumerate() {
+        for (i, table) in self.tables.values_mut().enumerate() {
             if !table.is_assigned {
                 debug!(
                     "laying out table for {}",
@@ -936,7 +584,7 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
         &mut self,
         layouter: &mut impl Layouter<F>,
     ) -> Result<(), Box<dyn Error>> {
-        for range_check in self.range_checks.ranges.values_mut() {
+        for range_check in self.range_checks.values_mut() {
             if !range_check.is_assigned {
                 debug!("laying out range check for {:?}", range_check.range);
                 range_check.layout(layouter)?;

src/circuit/ops/hybrid.rs

@@ -6,6 +6,7 @@ use crate::{
     tensor::{self, Tensor, TensorError, TensorType, ValTensor},
 };
 use halo2curves::ff::PrimeField;
+use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 // import run args from model
 
@@ -68,6 +69,14 @@ pub enum HybridOp {
         dim: usize,
         num_classes: usize,
     },
+    GatherElements {
+        dim: usize,
+        constant_idx: Option<Tensor<usize>>,
+    },
+    ScatterElements {
+        dim: usize,
+        constant_idx: Option<Tensor<usize>>,
+    },
 }
 
 impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
@@ -75,6 +84,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
     fn requires_homogenous_input_scales(&self) -> Vec<usize> {
         match self {
             HybridOp::Greater | HybridOp::Less | HybridOp::Equals => vec![0, 1],
+            HybridOp::ScatterElements { .. } => vec![0, 2],
             HybridOp::GreaterEqual | HybridOp::LessEqual => vec![0, 1],
             _ => vec![],
         }
@@ -88,42 +98,176 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
     fn f(&self, inputs: &[Tensor<F>]) -> Result<ForwardResult<F>, TensorError> {
         let x = inputs[0].clone().map(|x| felt_to_i128(x));
 
-        let res = match &self {
-            HybridOp::ReduceMax { axes, .. } => tensor::ops::max_axes(&x, axes)?,
-            HybridOp::ReduceMin { axes, .. } => tensor::ops::min_axes(&x, axes)?,
-            HybridOp::Div { denom, .. } => {
-                crate::tensor::ops::nonlinearities::const_div(&x, denom.0 as f64)
+        let (res, intermediate_lookups) = match &self {
+            HybridOp::ReduceMax { axes, .. } => {
+                let res = tensor::ops::max_axes(&x, axes)?;
+                let max_minus_one =
+                    Tensor::from(vec![x.clone().into_iter().max().unwrap() - 1].into_iter());
+                let unit = Tensor::from(vec![1].into_iter());
+                // relu(x - max(x - 1)
+                let inter_1 = (x.clone() - max_minus_one)?;
+                // relu(1 - sum(relu(inter_1)))
+                let inter_2 = (unit
+                    - tensor::ops::sum(&tensor::ops::nonlinearities::leakyrelu(&inter_1, 0.0))?)?;
+
+                (res.clone(), vec![inter_1, inter_2])
+            }
+            HybridOp::ReduceMin { axes, .. } => {
+                let res = tensor::ops::min_axes(&x, axes)?;
+                let min_plus_one =
+                    Tensor::from(vec![x.clone().into_iter().min().unwrap() + 1].into_iter());
+                let unit = Tensor::from(vec![1].into_iter());
+                // relu(min(x + 1) - x)
+                let inter_1 = (min_plus_one - x.clone())?;
+                // relu(1 - sum(relu(inter_1)))
+                let inter_2 = (unit
+                    - tensor::ops::sum(&tensor::ops::nonlinearities::leakyrelu(&inter_1, 0.0))?)?;
+                (res.clone(), vec![inter_1, inter_2])
+            }
+            HybridOp::Div {
+                denom,
+                use_range_check_for_int,
+                ..
+            } => {
+                let res = crate::tensor::ops::nonlinearities::const_div(&x, denom.0 as f64);
+                // if denom is a round number and use_range_check_for_int is true, use range check check
+                if denom.0.fract() == 0.0 && *use_range_check_for_int {
+                    let divisor = Tensor::from(vec![denom.0 as i128 / 2].into_iter());
+                    (res, vec![-divisor.clone(), divisor])
+                } else {
+                    (res, vec![x])
+                }
             }
             HybridOp::Recip {
                 input_scale,
                 output_scale,
-                ..
-            } => crate::tensor::ops::nonlinearities::recip(
-                &x,
-                input_scale.0 as f64,
-                output_scale.0 as f64,
-            ),
-            HybridOp::ReduceArgMax { dim } => tensor::ops::argmax_axes(&x, *dim)?,
-            HybridOp::ReduceArgMin { dim } => tensor::ops::argmin_axes(&x, *dim)?,
+                use_range_check_for_int,
+            } => {
+                let res = crate::tensor::ops::nonlinearities::recip(
+                    &x,
+                    input_scale.0 as f64,
+                    output_scale.0 as f64,
+                );
+                // if scale is a round number and use_range_check_for_int is true, use range check check
+                if input_scale.0.fract() == 0.0 && *use_range_check_for_int {
+                    let err_tol = Tensor::from(
+                        vec![(output_scale.0 * input_scale.0) as i128 / 2].into_iter(),
+                    );
+                    (res, vec![-err_tol.clone(), err_tol])
+                } else {
+                    (res, vec![x])
+                }
+            }
+            HybridOp::ReduceArgMax { dim } => {
+                let res = tensor::ops::argmax_axes(&x, *dim)?;
+                let indices = Tensor::from(0..x.dims()[*dim] as i128);
+                let mut inter_equals: Vec<Tensor<i128>> = vec![indices.clone(), -indices];
+                let inter =
+                    Op::f(&HybridOp::ReduceMax { axes: vec![*dim] }, inputs)?.intermediate_lookups;
+                inter_equals.extend(inter);
+
+                (res.clone(), inter_equals)
+            }
+            HybridOp::ReduceArgMin { dim } => {
+                let res = tensor::ops::argmin_axes(&x, *dim)?;
+                let indices = Tensor::from(0..x.dims()[*dim] as i128);
+                let mut inter_equals: Vec<Tensor<i128>> = vec![indices.clone(), -indices];
+                let inter =
+                    Op::f(&HybridOp::ReduceMin { axes: vec![*dim] }, inputs)?.intermediate_lookups;
+                inter_equals.extend(inter);
+
+                (res.clone(), inter_equals)
+            }
             HybridOp::Gather { dim, constant_idx } => {
                 if let Some(idx) = constant_idx {
-                    tensor::ops::gather(&x, idx, *dim)?
+                    log::debug!("idx: {}", idx.show());
+                    let res = tensor::ops::gather(&x, idx, *dim)?;
+                    (res.clone(), vec![])
                 } else {
                     let y = inputs[1].clone().map(|x| felt_to_i128(x));
-                    tensor::ops::gather(&x, &y.map(|x| x as usize), *dim)?
+                    let indices = Tensor::from(0..x.dims()[*dim] as i128);
+                    let inter_equals: Vec<Tensor<i128>> = vec![indices.clone(), -indices];
+                    let res = tensor::ops::gather(&x, &y.map(|x| x as usize), *dim)?;
+                    (res.clone(), inter_equals)
                 }
             }
             HybridOp::OneHot { dim, num_classes } => {
-                tensor::ops::one_hot(&x, *num_classes, *dim)?.clone()
+                let indices = Tensor::from(0..x.dims()[*dim] as i128);
+                let inter_equals: Vec<Tensor<i128>> = vec![indices.clone(), -indices];
+                let res = tensor::ops::one_hot(&x, *num_classes, *dim)?;
+                (res.clone(), inter_equals)
             }
+            HybridOp::TopK { dim, k, largest } => {
+                let res = tensor::ops::topk_axes(&x, *k, *dim, *largest)?;
 
-            HybridOp::TopK { dim, k, largest } => tensor::ops::topk_axes(&x, *k, *dim, *largest)?,
+                let mut inter_equals = x
+                    .clone()
+                    .into_iter()
+                    .flat_map(|elem| {
+                        tensor::ops::equals(&res, &vec![elem].into_iter().into())
+                            .unwrap()
+                            .1
+                    })
+                    .collect::<Vec<_>>();
+
+                // sort in descending order and take pairwise differences
+                inter_equals.push(
+                    x.into_iter()
+                        .sorted()
+                        .tuple_windows()
+                        .map(|(a, b)| b - a)
+                        .into(),
+                );
+
+                (res.clone(), inter_equals)
+            }
+            HybridOp::GatherElements { dim, constant_idx } => {
+                if let Some(idx) = constant_idx {
+                    log::debug!("idx: {}", idx.show());
+                    let res = tensor::ops::gather_elements(&x, idx, *dim)?;
+                    (res.clone(), vec![])
+                } else {
+                    let y = inputs[1].clone().map(|x| felt_to_i128(x));
+                    let indices = Tensor::from(0..x.dims()[*dim] as i128);
+                    let inter_equals: Vec<Tensor<i128>> = vec![indices.clone(), -indices];
+                    let res = tensor::ops::gather_elements(&x, &y.map(|x| x as usize), *dim)?;
+                    (res.clone(), inter_equals)
+                }
+            }
+            HybridOp::ScatterElements { dim, constant_idx } => {
+                if let Some(idx) = constant_idx {
+                    log::debug!("idx: {}", idx.show());
+                    let src = inputs[1].clone().map(|x| felt_to_i128(x));
+                    let res = tensor::ops::scatter(&x, idx, &src, *dim)?;
+                    (res.clone(), vec![])
+                } else {
+                    let idx = inputs[1].clone().map(|x| felt_to_i128(x) as usize);
+                    let src = inputs[2].clone().map(|x| felt_to_i128(x));
+                    let indices = Tensor::from(0..x.dims()[*dim] as i128);
+                    let inter_equals: Vec<Tensor<i128>> = vec![indices.clone(), -indices];
+                    let res = tensor::ops::scatter(&x, &idx, &src, *dim)?;
+                    (res.clone(), inter_equals)
+                }
+            }
             HybridOp::MaxPool2d {
                 padding,
                 stride,
                 pool_dims,
                 ..
-            } => tensor::ops::max_pool2d(&x, padding, stride, pool_dims)?,
+            } => {
+                let max_minus_one =
+                    Tensor::from(vec![x.clone().into_iter().max().unwrap() - 1].into_iter());
+                let unit = Tensor::from(vec![1].into_iter());
+                // relu(x - max(x - 1)
+                let inter_1 = (x.clone() - max_minus_one)?;
+                // relu(1 - sum(relu(inter_1)))
+                let inter_2 = (unit
+                    - tensor::ops::sum(&tensor::ops::nonlinearities::leakyrelu(&inter_1, 0.0))?)?;
+                (
+                    tensor::ops::max_pool2d(&x, padding, stride, pool_dims)?,
+                    vec![inter_1, inter_2],
+                )
+            }
             HybridOp::SumPool {
                 padding,
                 stride,
@@ -135,7 +279,10 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
             }
             HybridOp::RangeCheck(tol) => {
                 let y = inputs[1].clone().map(|x| felt_to_i128(x));
-                tensor::ops::nonlinearities::range_check_percent(&[x, y], 128, 128, tol.val)
+                (
+                    tensor::ops::nonlinearities::range_check_percent(&[x, y], 128, 128, tol.val),
+                    vec![],
+                )
             }
             HybridOp::Greater => {
                 let y = inputs[1].clone().map(|x| felt_to_i128(x));
@@ -162,7 +309,10 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
         // convert back to felt
         let output = res.map(|x| i128_to_felt(x));
 
-        Ok(ForwardResult { output })
+        Ok(ForwardResult {
+            output,
+            intermediate_lookups,
+        })
     }
 
     fn as_string(&self) -> String {
@@ -216,6 +366,8 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
             HybridOp::TopK { k, dim, largest } => {
                 format!("TOPK (k={}, dim={}, largest={})", k, dim, largest)
             }
+            HybridOp::GatherElements { dim, .. } => format!("GATHERELEMENTS (dim={})", dim),
+            HybridOp::ScatterElements { dim, .. } => format!("SCATTERELEMENTS (dim={})", dim),
             HybridOp::OneHot { dim, num_classes } => {
                 format!("ONEHOT (dim={}, num_classes={})", dim, num_classes)
             }
@@ -277,7 +429,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
                 ..
             } => {
                 if denom.0.fract() == 0.0 && *use_range_check_for_int {
-                    layouts::loop_div(
+                    layouts::div(
                         config,
                         region,
                         values[..].try_into()?,
@@ -288,7 +440,9 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
                         config,
                         region,
                         values.try_into()?,
-                        &LookupOp::Div { denom: *denom },
+                        &LookupOp::Div {
+                            denom: denom.clone(),
+                        },
                     )?
                 }
             }
@@ -299,7 +453,26 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
                     layouts::gather(config, region, values[..].try_into()?, *dim)?
                 }
             }
-
+            HybridOp::GatherElements { dim, constant_idx } => {
+                if let Some(idx) = constant_idx {
+                    tensor::ops::gather_elements(values[0].get_inner_tensor()?, idx, *dim)?.into()
+                } else {
+                    layouts::gather_elements(config, region, values[..].try_into()?, *dim)?
+                }
+            }
+            HybridOp::ScatterElements { dim, constant_idx } => {
+                if let Some(idx) = constant_idx {
+                    tensor::ops::scatter(
+                        values[0].get_inner_tensor()?,
+                        idx,
+                        values[1].get_inner_tensor()?,
+                        *dim,
+                    )?
+                    .into()
+                } else {
+                    layouts::scatter_elements(config, region, values[..].try_into()?, *dim)?
+                }
+            }
             HybridOp::MaxPool2d {
                 padding,
                 stride,

src/circuit/ops/lookup.rs

@@ -227,7 +227,10 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for LookupOp {
 
         let output = res.map(|x| i128_to_felt(x));
 
-        Ok(ForwardResult { output })
+        Ok(ForwardResult {
+            output,
+            intermediate_lookups: vec![],
+        })
     }
 
     /// Returns the name of the operation
@@ -243,10 +246,10 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for LookupOp {
             LookupOp::Max { scale, a } => format!("MAX(scale={}, a={})", scale, a),
             LookupOp::Min { scale, a } => format!("MIN(scale={}, a={})", scale, a),
             LookupOp::Sign => "SIGN".into(),
-            LookupOp::GreaterThan { a } => format!("GREATER_THAN(a={})", a),
-            LookupOp::GreaterThanEqual { a } => format!("GREATER_THAN_EQUAL(a={})", a),
-            LookupOp::LessThan { a } => format!("LESS_THAN(a={})", a),
-            LookupOp::LessThanEqual { a } => format!("LESS_THAN_EQUAL(a={})", a),
+            LookupOp::GreaterThan { .. } => "GREATER_THAN".into(),
+            LookupOp::GreaterThanEqual { .. } => "GREATER_THAN_EQUAL".into(),
+            LookupOp::LessThan { .. } => "LESS_THAN".into(),
+            LookupOp::LessThanEqual { .. } => "LESS_THAN_EQUAL".into(),
             LookupOp::Recip {
                 input_scale,
                 output_scale,

src/circuit/ops/mod.rs

@@ -29,6 +29,7 @@ pub mod region;
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct ForwardResult<F: PrimeField + TensorType + PartialOrd> {
     pub(crate) output: Tensor<F>,
+    pub(crate) intermediate_lookups: Vec<Tensor<i128>>,
 }
 
 /// A trait representing operations that can be represented as constraints in a circuit.
@@ -177,6 +178,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for Input {
     fn f(&self, x: &[Tensor<F>]) -> Result<ForwardResult<F>, TensorError> {
         Ok(ForwardResult {
             output: x[0].clone(),
+            intermediate_lookups: vec![],
         })
     }
 
@@ -199,7 +201,6 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for Input {
                         config,
                         region,
                         values[..].try_into()?,
-                        true,
                     )?))
                 }
                 _ => Ok(Some(super::layouts::identity(
@@ -302,7 +303,10 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
     fn f(&self, _: &[Tensor<F>]) -> Result<ForwardResult<F>, TensorError> {
         let output = self.quantized_values.clone();
 
-        Ok(ForwardResult { output })
+        Ok(ForwardResult {
+            output,
+            intermediate_lookups: vec![],
+        })
     }
 
     fn as_string(&self) -> String {

src/circuit/ops/poly.rs

@@ -1,6 +1,5 @@
 use crate::{
     circuit::layouts,
-    fieldutils::felt_to_i128,
     tensor::{self, Tensor, TensorError},
 };
 
@@ -10,21 +9,6 @@ use super::{base::BaseOp, *};
 /// An enum representing the operations that can be expressed as arithmetic (non lookup) operations.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum PolyOp {
-    GatherElements {
-        dim: usize,
-        constant_idx: Option<Tensor<usize>>,
-    },
-    GatherND {
-        batch_dims: usize,
-        indices: Option<Tensor<usize>>,
-    },
-    ScatterElements {
-        dim: usize,
-        constant_idx: Option<Tensor<usize>>,
-    },
-    ScatterND {
-        constant_idx: Option<Tensor<usize>>,
-    },
     MultiBroadcastTo {
         shape: Vec<usize>,
     },
@@ -67,6 +51,8 @@ pub enum PolyOp {
         len_prod: usize,
     },
     Pow(u32),
+    Pack(u32, u32),
+    GlobalSumPool,
     Concat {
         axis: usize,
     },
@@ -95,10 +81,6 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
 
     fn as_string(&self) -> String {
         match &self {
-            PolyOp::GatherElements { dim, .. } => format!("GATHERELEMENTS (dim={})", dim),
-            PolyOp::GatherND { batch_dims, .. } => format!("GATHERND (batch_dims={})", batch_dims),
-            PolyOp::ScatterElements { dim, .. } => format!("SCATTERELEMENTS (dim={})", dim),
-            PolyOp::ScatterND { .. } => "SCATTERND".into(),
             PolyOp::MultiBroadcastTo { shape } => format!("MULTIBROADCASTTO (shape={:?})", shape),
             PolyOp::MoveAxis { .. } => "MOVEAXIS".into(),
             PolyOp::Downsample { .. } => "DOWNSAMPLE".into(),
@@ -117,6 +99,8 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
             PolyOp::Sum { .. } => "SUM".into(),
             PolyOp::Prod { .. } => "PROD".into(),
             PolyOp::Pow(_) => "POW".into(),
+            PolyOp::Pack(_, _) => "PACK".into(),
+            PolyOp::GlobalSumPool => "GLOBALSUMPOOL".into(),
             PolyOp::Conv { .. } => "CONV".into(),
             PolyOp::DeConv { .. } => "DECONV".into(),
             PolyOp::Concat { axis } => format!("CONCAT (axis={})", axis),
@@ -186,6 +170,13 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
                 output_padding,
                 stride,
             } => tensor::ops::deconv(&inputs, *padding, *output_padding, *stride),
+            PolyOp::Pack(base, scale) => {
+                if 1 != inputs.len() {
+                    return Err(TensorError::DimMismatch("pack inputs".to_string()));
+                }
+
+                tensor::ops::pack(&inputs[0], F::from(*base as u64), *scale)
+            }
             PolyOp::Pow(u) => {
                 if 1 != inputs.len() {
                     return Err(TensorError::DimMismatch("pow inputs".to_string()));
@@ -204,6 +195,7 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
                 }
                 tensor::ops::prod_axes(&inputs[0], axes)
             }
+            PolyOp::GlobalSumPool => unreachable!(),
             PolyOp::Concat { axis } => {
                 tensor::ops::concat(&inputs.iter().collect::<Vec<_>>(), *axis)
             }
@@ -211,63 +203,14 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
                 if 1 != inputs.len() {
                     return Err(TensorError::DimMismatch("slice inputs".to_string()));
                 }
-                tensor::ops::slice(&inputs[0], axis, start, end)
-            }
-            PolyOp::GatherElements { dim, constant_idx } => {
-                let x = inputs[0].clone();
-                let y = if let Some(idx) = constant_idx {
-                    idx.clone()
-                } else {
-                    inputs[1].clone().map(|x| felt_to_i128(x) as usize)
-                };
-                tensor::ops::gather_elements(&x, &y, *dim)
-            }
-            PolyOp::GatherND {
-                indices,
-                batch_dims,
-            } => {
-                let x = inputs[0].clone();
-                let y = if let Some(idx) = indices {
-                    idx.clone()
-                } else {
-                    inputs[1].clone().map(|x| felt_to_i128(x) as usize)
-                };
-                tensor::ops::gather_nd(&x, &y, *batch_dims)
-            }
-            PolyOp::ScatterElements { dim, constant_idx } => {
-                let x = inputs[0].clone();
-
-                let idx = if let Some(idx) = constant_idx {
-                    idx.clone()
-                } else {
-                    inputs[1].clone().map(|x| felt_to_i128(x) as usize)
-                };
-
-                let src = if constant_idx.is_some() {
-                    inputs[1].clone()
-                } else {
-                    inputs[2].clone()
-                };
-                tensor::ops::scatter(&x, &idx, &src, *dim)
-            }
-
-            PolyOp::ScatterND { constant_idx } => {
-                let x = inputs[0].clone();
-                let idx = if let Some(idx) = constant_idx {
-                    idx.clone()
-                } else {
-                    inputs[1].clone().map(|x| felt_to_i128(x) as usize)
-                };
-                let src = if constant_idx.is_some() {
-                    inputs[1].clone()
-                } else {
-                    inputs[2].clone()
-                };
-                tensor::ops::scatter_nd(&x, &idx, &src)
+                Ok(tensor::ops::slice(&inputs[0], axis, start, end)?)
             }
         }?;
 
-        Ok(ForwardResult { output: res })
+        Ok(ForwardResult {
+            output: res,
+            intermediate_lookups: vec![],
+        })
     }
 
     fn layout(
@@ -308,48 +251,6 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
             PolyOp::Conv { padding, stride } => {
                 layouts::conv(config, region, values[..].try_into()?, *padding, *stride)?
             }
-            PolyOp::GatherElements { dim, constant_idx } => {
-                if let Some(idx) = constant_idx {
-                    tensor::ops::gather_elements(values[0].get_inner_tensor()?, idx, *dim)?.into()
-                } else {
-                    layouts::gather_elements(config, region, values[..].try_into()?, *dim)?.0
-                }
-            }
-            PolyOp::GatherND {
-                batch_dims,
-                indices,
-            } => {
-                if let Some(idx) = indices {
-                    tensor::ops::gather_nd(values[0].get_inner_tensor()?, idx, *batch_dims)?.into()
-                } else {
-                    layouts::gather_nd(config, region, values[..].try_into()?, *batch_dims)?.0
-                }
-            }
-            PolyOp::ScatterElements { dim, constant_idx } => {
-                if let Some(idx) = constant_idx {
-                    tensor::ops::scatter(
-                        values[0].get_inner_tensor()?,
-                        idx,
-                        values[1].get_inner_tensor()?,
-                        *dim,
-                    )?
-                    .into()
-                } else {
-                    layouts::scatter_elements(config, region, values[..].try_into()?, *dim)?
-                }
-            }
-            PolyOp::ScatterND { constant_idx } => {
-                if let Some(idx) = constant_idx {
-                    tensor::ops::scatter_nd(
-                        values[0].get_inner_tensor()?,
-                        idx,
-                        values[1].get_inner_tensor()?,
-                    )?
-                    .into()
-                } else {
-                    layouts::scatter_nd(config, region, values[..].try_into()?)?
-                }
-            }
             PolyOp::DeConv {
                 padding,
                 output_padding,
@@ -380,6 +281,10 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
                 input
             }
             PolyOp::Pow(exp) => layouts::pow(config, region, values[..].try_into()?, *exp)?,
+            PolyOp::Pack(base, scale) => {
+                layouts::pack(config, region, values[..].try_into()?, *base, *scale)?
+            }
+            PolyOp::GlobalSumPool => unreachable!(),
             PolyOp::Concat { axis } => layouts::concat(values[..].try_into()?, axis)?,
             PolyOp::Slice { axis, start, end } => {
                 layouts::slice(config, region, values[..].try_into()?, axis, start, end)?
@@ -447,10 +352,6 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
             vec![1, 2]
         } else if matches!(self, PolyOp::Concat { .. }) {
             (0..100).collect()
-        } else if matches!(self, PolyOp::ScatterElements { .. })
-            | matches!(self, PolyOp::ScatterND { .. })
-        {
-            vec![0, 2]
         } else {
             vec![]
         }

src/circuit/ops/region.rs

@@ -16,70 +16,8 @@ use std::{
     },
 };
 
-use portable_atomic::AtomicI128 as AtomicInt;
-
 use super::lookup::LookupOp;
 
-/// Dynamic lookup index
-#[derive(Clone, Debug, Default)]
-pub struct DynamicLookupIndex {
-    index: usize,
-    col_coord: usize,
-}
-
-impl DynamicLookupIndex {
-    /// Create a new dynamic lookup index
-    pub fn new(index: usize, col_coord: usize) -> DynamicLookupIndex {
-        DynamicLookupIndex { index, col_coord }
-    }
-
-    /// Get the lookup index
-    pub fn index(&self) -> usize {
-        self.index
-    }
-
-    /// Get the column coord
-    pub fn col_coord(&self) -> usize {
-        self.col_coord
-    }
-
-    /// update with another dynamic lookup index
-    pub fn update(&mut self, other: &DynamicLookupIndex) {
-        self.index += other.index;
-        self.col_coord += other.col_coord;
-    }
-}
-
-/// Dynamic lookup index
-#[derive(Clone, Debug, Default)]
-pub struct ShuffleIndex {
-    index: usize,
-    col_coord: usize,
-}
-
-impl ShuffleIndex {
-    /// Create a new dynamic lookup index
-    pub fn new(index: usize, col_coord: usize) -> ShuffleIndex {
-        ShuffleIndex { index, col_coord }
-    }
-
-    /// Get the lookup index
-    pub fn index(&self) -> usize {
-        self.index
-    }
-
-    /// Get the column coord
-    pub fn col_coord(&self) -> usize {
-        self.col_coord
-    }
-
-    /// update with another shuffle index
-    pub fn update(&mut self, other: &ShuffleIndex) {
-        self.index += other.index;
-        self.col_coord += other.col_coord;
-    }
-}
-
 /// Region error
 #[derive(Debug, thiserror::Error)]
 pub enum RegionError {
@@ -126,14 +64,8 @@ pub struct RegionCtx<'a, F: PrimeField + TensorType + PartialOrd> {
     linear_coord: usize,
     num_inner_cols: usize,
     total_constants: usize,
-    dynamic_lookup_index: DynamicLookupIndex,
-    shuffle_index: ShuffleIndex,
     used_lookups: HashSet<LookupOp>,
     used_range_checks: HashSet<Range>,
-    max_lookup_inputs: i128,
-    min_lookup_inputs: i128,
-    max_range_size: i128,
-    throw_range_check_error: bool,
 }
 
 impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
@@ -142,31 +74,6 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
         self.total_constants += n;
     }
 
-    ///
-    pub fn increment_dynamic_lookup_index(&mut self, n: usize) {
-        self.dynamic_lookup_index.index += n;
-    }
-
-    ///
-    pub fn increment_dynamic_lookup_col_coord(&mut self, n: usize) {
-        self.dynamic_lookup_index.col_coord += n;
-    }
-
-    ///
-    pub fn increment_shuffle_index(&mut self, n: usize) {
-        self.shuffle_index.index += n;
-    }
-
-    ///
-    pub fn increment_shuffle_col_coord(&mut self, n: usize) {
-        self.shuffle_index.col_coord += n;
-    }
-
-    ///
-    pub fn throw_range_check_error(&self) -> bool {
-        self.throw_range_check_error
-    }
-
     /// Create a new region context
     pub fn new(region: Region<'a, F>, row: usize, num_inner_cols: usize) -> RegionCtx<'a, F> {
         let region = Some(RefCell::new(region));
@@ -178,14 +85,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
             row,
             linear_coord,
             total_constants: 0,
-            dynamic_lookup_index: DynamicLookupIndex::default(),
-            shuffle_index: ShuffleIndex::default(),
             used_lookups: HashSet::new(),
             used_range_checks: HashSet::new(),
-            max_lookup_inputs: 0,
-            min_lookup_inputs: 0,
-            max_range_size: 0,
-            throw_range_check_error: false,
         }
     }
     /// Create a new region context from a wrapped region
@@ -193,8 +94,6 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
         region: Option<RefCell<Region<'a, F>>>,
         row: usize,
         num_inner_cols: usize,
-        dynamic_lookup_index: DynamicLookupIndex,
-        shuffle_index: ShuffleIndex,
     ) -> RegionCtx<'a, F> {
         let linear_coord = row * num_inner_cols;
         RegionCtx {
@@ -203,23 +102,13 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
             linear_coord,
             row,
             total_constants: 0,
-            dynamic_lookup_index,
-            shuffle_index,
             used_lookups: HashSet::new(),
             used_range_checks: HashSet::new(),
-            max_lookup_inputs: 0,
-            min_lookup_inputs: 0,
-            max_range_size: 0,
-            throw_range_check_error: false,
         }
     }
 
     /// Create a new region context
-    pub fn new_dummy(
-        row: usize,
-        num_inner_cols: usize,
-        throw_range_check_error: bool,
-    ) -> RegionCtx<'a, F> {
+    pub fn new_dummy(row: usize, num_inner_cols: usize) -> RegionCtx<'a, F> {
         let region = None;
         let linear_coord = row * num_inner_cols;
 
@@ -229,14 +118,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
             linear_coord,
             row,
             total_constants: 0,
-            dynamic_lookup_index: DynamicLookupIndex::default(),
-            shuffle_index: ShuffleIndex::default(),
             used_lookups: HashSet::new(),
             used_range_checks: HashSet::new(),
-            max_lookup_inputs: 0,
-            min_lookup_inputs: 0,
-            max_range_size: 0,
-            throw_range_check_error,
         }
     }
 
@@ -246,7 +129,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
         linear_coord: usize,
         total_constants: usize,
         num_inner_cols: usize,
-        throw_range_check_error: bool,
+        used_lookups: HashSet<LookupOp>,
+        used_range_checks: HashSet<Range>,
     ) -> RegionCtx<'a, F> {
         let region = None;
         RegionCtx {
@@ -255,14 +139,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
             linear_coord,
             row,
             total_constants,
-            dynamic_lookup_index: DynamicLookupIndex::default(),
-            shuffle_index: ShuffleIndex::default(),
-            used_lookups: HashSet::new(),
-            used_range_checks: HashSet::new(),
-            max_lookup_inputs: 0,
-            min_lookup_inputs: 0,
-            max_range_size: 0,
-            throw_range_check_error,
+            used_lookups,
+            used_range_checks,
         }
     }
 
@@ -302,7 +180,6 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
 
     /// Create a new region context per loop iteration
     /// hacky but it works
-
     pub fn dummy_loop<T: TensorType + Send + Sync>(
         &mut self,
         output: &mut Tensor<T>,
@@ -313,12 +190,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
         let row = AtomicUsize::new(self.row());
         let linear_coord = AtomicUsize::new(self.linear_coord());
         let constants = AtomicUsize::new(self.total_constants());
-        let max_lookup_inputs = AtomicInt::new(self.max_lookup_inputs());
-        let min_lookup_inputs = AtomicInt::new(self.min_lookup_inputs());
         let lookups = Arc::new(Mutex::new(self.used_lookups.clone()));
         let range_checks = Arc::new(Mutex::new(self.used_range_checks.clone()));
-        let dynamic_lookup_index = Arc::new(Mutex::new(self.dynamic_lookup_index.clone()));
-        let shuffle_index = Arc::new(Mutex::new(self.shuffle_index.clone()));
 
         *output = output
             .par_enum_map(|idx, _| {
@@ -334,7 +207,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
                     starting_linear_coord,
                     starting_constants,
                     self.num_inner_cols,
-                    self.throw_range_check_error,
+                    HashSet::new(),
+                    HashSet::new(),
                 );
                 let res = inner_loop_function(idx, &mut local_reg);
                 // we update the offset and constants
@@ -347,32 +221,19 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
                     local_reg.total_constants() - starting_constants,
                     Ordering::SeqCst,
                 );
-
-                max_lookup_inputs.fetch_max(local_reg.max_lookup_inputs(), Ordering::SeqCst);
-                min_lookup_inputs.fetch_min(local_reg.min_lookup_inputs(), Ordering::SeqCst);
                 // update the lookups
                 let mut lookups = lookups.lock().unwrap();
                 lookups.extend(local_reg.used_lookups());
-                // update the range checks
                 let mut range_checks = range_checks.lock().unwrap();
                 range_checks.extend(local_reg.used_range_checks());
-                // update the dynamic lookup index
-                let mut dynamic_lookup_index = dynamic_lookup_index.lock().unwrap();
-                dynamic_lookup_index.update(&local_reg.dynamic_lookup_index);
-                // update the shuffle index
-                let mut shuffle_index = shuffle_index.lock().unwrap();
-                shuffle_index.update(&local_reg.shuffle_index);
-
                 res
             })
-            .map_err(|e| RegionError::from(format!("dummy_loop: {:?}", e)))?;
+            .map_err(|e| {
+                log::error!("dummy_loop: {:?}", e);
+                Error::Synthesis
+            })?;
         self.total_constants = constants.into_inner();
         self.linear_coord = linear_coord.into_inner();
-        #[allow(trivial_numeric_casts)]
-        {
-            self.max_lookup_inputs = max_lookup_inputs.into_inner();
-            self.min_lookup_inputs = min_lookup_inputs.into_inner();
-        }
         self.row = row.into_inner();
         self.used_lookups = Arc::try_unwrap(lookups)
             .map_err(|e| RegionError::from(format!("dummy_loop: failed to get lookups: {:?}", e)))?
@@ -388,81 +249,23 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
             .map_err(|e| {
                 RegionError::from(format!("dummy_loop: failed to get range checks: {:?}", e))
             })?;
-        self.dynamic_lookup_index = Arc::try_unwrap(dynamic_lookup_index)
-            .map_err(|e| {
-                RegionError::from(format!(
-                    "dummy_loop: failed to get dynamic lookup index: {:?}",
-                    e
-                ))
-            })?
-            .into_inner()
-            .map_err(|e| {
-                RegionError::from(format!(
-                    "dummy_loop: failed to get dynamic lookup index: {:?}",
-                    e
-                ))
-            })?;
-        self.shuffle_index = Arc::try_unwrap(shuffle_index)
-            .map_err(|e| {
-                RegionError::from(format!("dummy_loop: failed to get shuffle index: {:?}", e))
-            })?
-            .into_inner()
-            .map_err(|e| {
-                RegionError::from(format!("dummy_loop: failed to get shuffle index: {:?}", e))
-            })?;
 
         Ok(())
     }
 
-    /// Update the max and min from inputs
-    pub fn update_max_min_lookup_inputs(
-        &mut self,
-        inputs: &[ValTensor<F>],
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        let (mut min, mut max) = (0, 0);
-        for i in inputs {
-            max = max.max(i.get_int_evals()?.into_iter().max().unwrap_or_default());
-            min = min.min(i.get_int_evals()?.into_iter().min().unwrap_or_default());
-        }
-        self.max_lookup_inputs = self.max_lookup_inputs.max(max);
-        self.min_lookup_inputs = self.min_lookup_inputs.min(min);
-        Ok(())
-    }
-
-    /// Update the max and min from inputs
-    pub fn update_max_min_lookup_range(
-        &mut self,
-        range: Range,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        if range.0 > range.1 {
-            return Err("update_max_min_lookup_range: invalid range".into());
-        }
-
-        let range_size = (range.1 - range.0).abs();
-
-        self.max_range_size = self.max_range_size.max(range_size);
-        Ok(())
-    }
-
     /// Check if the region is dummy
     pub fn is_dummy(&self) -> bool {
         self.region.is_none()
     }
 
     /// add used lookup
-    pub fn add_used_lookup(
-        &mut self,
-        lookup: LookupOp,
-        inputs: &[ValTensor<F>],
-    ) -> Result<(), Box<dyn std::error::Error>> {
+    pub fn add_used_lookup(&mut self, lookup: LookupOp) {
         self.used_lookups.insert(lookup);
-        self.update_max_min_lookup_inputs(inputs)
     }
 
     /// add used range check
-    pub fn add_used_range_check(&mut self, range: Range) -> Result<(), Box<dyn std::error::Error>> {
+    pub fn add_used_range_check(&mut self, range: Range) {
         self.used_range_checks.insert(range);
-        self.update_max_min_lookup_range(range)
     }
 
     /// Get the offset
@@ -480,26 +283,6 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
         self.total_constants
     }
 
-    /// Get the dynamic lookup index
-    pub fn dynamic_lookup_index(&self) -> usize {
-        self.dynamic_lookup_index.index
-    }
-
-    /// Get the dynamic lookup column coordinate
-    pub fn dynamic_lookup_col_coord(&self) -> usize {
-        self.dynamic_lookup_index.col_coord
-    }
-
-    /// Get the shuffle index
-    pub fn shuffle_index(&self) -> usize {
-        self.shuffle_index.index
-    }
-
-    /// Get the shuffle column coordinate
-    pub fn shuffle_col_coord(&self) -> usize {
-        self.shuffle_index.col_coord
-    }
-
     /// get used lookups
     pub fn used_lookups(&self) -> HashSet<LookupOp> {
         self.used_lookups.clone()
@@ -510,21 +293,6 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
         self.used_range_checks.clone()
     }
 
-    /// max lookup inputs
-    pub fn max_lookup_inputs(&self) -> i128 {
-        self.max_lookup_inputs
-    }
-
-    /// min lookup inputs
-    pub fn min_lookup_inputs(&self) -> i128 {
-        self.min_lookup_inputs
-    }
-
-    /// max range check
-    pub fn max_range_size(&self) -> i128 {
-        self.max_range_size
-    }
-
     /// Assign a constant value
     pub fn assign_constant(&mut self, var: &VarTensor, value: F) -> Result<ValType<F>, Error> {
         self.total_constants += 1;
@@ -549,38 +317,6 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
         }
     }
 
-    ///
-    pub fn combined_dynamic_shuffle_coord(&self) -> usize {
-        self.dynamic_lookup_col_coord() + self.shuffle_col_coord()
-    }
-
-    /// Assign a valtensor to a vartensor
-    pub fn assign_dynamic_lookup(
-        &mut self,
-        var: &VarTensor,
-        values: &ValTensor<F>,
-    ) -> Result<ValTensor<F>, Error> {
-        self.total_constants += values.num_constants();
-        if let Some(region) = &self.region {
-            var.assign(
-                &mut region.borrow_mut(),
-                self.combined_dynamic_shuffle_coord(),
-                values,
-            )
-        } else {
-            Ok(values.clone())
-        }
-    }
-
-    /// Assign a valtensor to a vartensor
-    pub fn assign_shuffle(
-        &mut self,
-        var: &VarTensor,
-        values: &ValTensor<F>,
-    ) -> Result<ValTensor<F>, Error> {
-        self.assign_dynamic_lookup(var, values)
-    }
-
     /// Assign a valtensor to a vartensor
     pub fn assign_with_omissions(
         &mut self,

src/circuit/table.rs

@@ -130,12 +130,14 @@ impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
     pub fn cal_bit_range(bits: usize, reserved_blinding_rows: usize) -> usize {
         2usize.pow(bits as u32) - reserved_blinding_rows
     }
-}
 
-///
-pub fn num_cols_required(range_len: i128, col_size: usize) -> usize {
-    // number of cols needed to store the range
-    (range_len / (col_size as i128)) as usize + 1
+    ///
+    pub fn num_cols_required(range: Range, col_size: usize) -> usize {
+        // double it to be safe
+        let range_len = range.1 - range.0;
+        // number of cols needed to store the range
+        (range_len / (col_size as i128)) as usize + 1
+    }
 }
 
 impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
@@ -150,7 +152,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
         let factors = cs.blinding_factors() + RESERVED_BLINDING_ROWS_PAD;
         let col_size = Self::cal_col_size(logrows, factors);
         // number of cols needed to store the range
-        let num_cols = num_cols_required((range.1 - range.0).abs(), col_size);
+        let num_cols = Self::num_cols_required(range, col_size);
 
         log::debug!("table range: {:?}", range);
 
@@ -263,9 +265,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
 #[derive(Clone, Debug)]
 pub struct RangeCheck<F: PrimeField> {
     /// Input to table.
-    pub inputs: Vec<TableColumn>,
-    /// col size
-    pub col_size: usize,
+    pub input: TableColumn,
     /// selector cn
     pub selector_constructor: SelectorConstructor<F>,
     /// Flags if table has been previously assigned to.
@@ -277,10 +277,8 @@ pub struct RangeCheck<F: PrimeField> {
 
 impl<F: PrimeField + TensorType + PartialOrd> RangeCheck<F> {
     /// get first_element of column
-    pub fn get_first_element(&self, chunk: usize) -> F {
-        let chunk = chunk as i128;
-        // we index from 1 to prevent soundness issues
-        i128_to_felt(chunk * (self.col_size as i128) + self.range.0)
+    pub fn get_first_element(&self) -> F {
+        i128_to_felt(self.range.0)
     }
 
     ///
@@ -292,58 +290,24 @@ impl<F: PrimeField + TensorType + PartialOrd> RangeCheck<F> {
     pub fn cal_bit_range(bits: usize, reserved_blinding_rows: usize) -> usize {
         2usize.pow(bits as u32) - reserved_blinding_rows
     }
-
-    /// get column index given input
-    pub fn get_col_index(&self, input: F) -> F {
-        //    range is split up into chunks of size col_size, find the chunk that input is in
-        let chunk =
-            (crate::fieldutils::felt_to_i128(input) - self.range.0).abs() / (self.col_size as i128);
-
-        i128_to_felt(chunk)
-    }
 }
 
 impl<F: PrimeField + TensorType + PartialOrd> RangeCheck<F> {
     /// Configures the table.
-    pub fn configure(cs: &mut ConstraintSystem<F>, range: Range, logrows: usize) -> RangeCheck<F> {
+    pub fn configure(cs: &mut ConstraintSystem<F>, range: Range) -> RangeCheck<F> {
         log::debug!("range check range: {:?}", range);
 
-        let factors = cs.blinding_factors() + RESERVED_BLINDING_ROWS_PAD;
-        let col_size = Self::cal_col_size(logrows, factors);
-        // number of cols needed to store the range
-        let num_cols = num_cols_required((range.1 - range.0).abs(), col_size);
-
-        let inputs = {
-            let mut cols = vec![];
-            for _ in 0..num_cols {
-                cols.push(cs.lookup_table_column());
-            }
-            cols
-        };
-
-        let num_cols = inputs.len();
-
-        if num_cols > 1 {
-            warn!("Using {} columns for range-check.", num_cols);
-        }
+        let inputs = cs.lookup_table_column();
 
         RangeCheck {
-            inputs,
-            col_size,
+            input: inputs,
             is_assigned: false,
-            selector_constructor: SelectorConstructor::new(num_cols),
+            selector_constructor: SelectorConstructor::new(2),
             range,
             _marker: PhantomData,
         }
     }
 
-    /// Take a linear coordinate and output the (column, row) position in the storage block.
-    pub fn cartesian_coord(&self, linear_coord: usize) -> (usize, usize) {
-        let x = linear_coord / self.col_size;
-        let y = linear_coord % self.col_size;
-        (x, y)
-    }
-
     /// Assigns values to the constraints generated when calling `configure`.
     pub fn layout(&mut self, layouter: &mut impl Layouter<F>) -> Result<(), Box<dyn Error>> {
         if self.is_assigned {
@@ -354,43 +318,28 @@ impl<F: PrimeField + TensorType + PartialOrd> RangeCheck<F> {
         let largest = self.range.1;
 
         let inputs: Tensor<F> = Tensor::from(smallest..=largest).map(|x| i128_to_felt(x));
-        let chunked_inputs = inputs.chunks(self.col_size);
 
         self.is_assigned = true;
 
-        let col_multipliers: Vec<F> = (0..chunked_inputs.len())
-            .map(|x| self.selector_constructor.get_selector_val_at_idx(x))
-            .collect();
-
-        let _ = chunked_inputs
-            .enumerate()
-            .map(|(chunk_idx, inputs)| {
-                layouter.assign_table(
-                    || "range check table",
-                    |mut table| {
-                        let _ = inputs
-                            .iter()
-                            .enumerate()
-                            .map(|(mut row_offset, input)| {
-                                let col_multiplier = col_multipliers[chunk_idx];
-
-                                row_offset += chunk_idx * self.col_size;
-                                let (x, y) = self.cartesian_coord(row_offset);
-                                table.assign_cell(
-                                    || format!("rc_i_col row {}", row_offset),
-                                    self.inputs[x],
-                                    y,
-                                    || Value::known(*input * col_multiplier),
-                                )?;
-
-                                Ok(())
-                            })
-                            .collect::<Result<Vec<()>, halo2_proofs::plonk::Error>>()?;
+        layouter.assign_table(
+            || "range check table",
+            |mut table| {
+                let _ = inputs
+                    .iter()
+                    .enumerate()
+                    .map(|(row_offset, input)| {
+                        table.assign_cell(
+                            || format!("rc_i_col row {}", row_offset),
+                            self.input,
+                            row_offset,
+                            || Value::known(*input),
+                        )?;
                         Ok(())
-                    },
-                )
-            })
-            .collect::<Result<Vec<()>, halo2_proofs::plonk::Error>>()?;
+                    })
+                    .collect::<Result<Vec<()>, halo2_proofs::plonk::Error>>()?;
+                Ok(())
+            },
+        )?;
         Ok(())
     }
 }

src/circuit/tests.rs

@@ -1,3 +1,4 @@
+use crate::circuit::ops::hybrid::HybridOp;
 use crate::circuit::ops::poly::PolyOp;
 use crate::circuit::*;
 use crate::tensor::{Tensor, TensorType, ValTensor, VarTensor};
@@ -245,7 +246,7 @@ mod matmul_col_overflow {
 #[cfg(test)]
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 mod matmul_col_ultra_overflow_double_col {
-    use halo2_proofs::poly::commitment::{Params, ParamsProver};
+    use halo2_proofs::poly::commitment::ParamsProver;
 
     use super::*;
 
@@ -348,22 +349,19 @@ mod matmul_col_ultra_overflow_double_col {
         let strategy =
             halo2_proofs::poly::kzg::strategy::SingleStrategy::new(params.verifier_params());
         let vk = pk.get_vk();
-        let result = crate::pfsys::verify_proof_circuit_kzg(
-            params.verifier_params(),
-            proof,
-            vk,
-            strategy,
-            params.n(),
-        );
+        let result =
+            crate::pfsys::verify_proof_circuit_kzg(params.verifier_params(), proof, vk, strategy);
 
         assert!(result.is_ok());
+
+        println!("done.");
     }
 }
 
 #[cfg(test)]
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 mod matmul_col_ultra_overflow {
-    use halo2_proofs::poly::commitment::{Params, ParamsProver};
+    use halo2_proofs::poly::commitment::ParamsProver;
 
     use super::*;
 
@@ -465,15 +463,12 @@ mod matmul_col_ultra_overflow {
         let strategy =
             halo2_proofs::poly::kzg::strategy::SingleStrategy::new(params.verifier_params());
         let vk = pk.get_vk();
-        let result = crate::pfsys::verify_proof_circuit_kzg(
-            params.verifier_params(),
-            proof,
-            vk,
-            strategy,
-            params.n(),
-        );
+        let result =
+            crate::pfsys::verify_proof_circuit_kzg(params.verifier_params(), proof, vk, strategy);
 
         assert!(result.is_ok());
+
+        println!("done.");
     }
 }
 
@@ -1145,7 +1140,7 @@ mod conv {
 #[cfg(test)]
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 mod conv_col_ultra_overflow {
-    use halo2_proofs::poly::commitment::{Params, ParamsProver};
+    use halo2_proofs::poly::commitment::ParamsProver;
 
     use super::*;
 
@@ -1267,15 +1262,12 @@ mod conv_col_ultra_overflow {
         let strategy =
             halo2_proofs::poly::kzg::strategy::SingleStrategy::new(params.verifier_params());
         let vk = pk.get_vk();
-        let result = crate::pfsys::verify_proof_circuit_kzg(
-            params.verifier_params(),
-            proof,
-            vk,
-            strategy,
-            params.n(),
-        );
+        let result =
+            crate::pfsys::verify_proof_circuit_kzg(params.verifier_params(), proof, vk, strategy);
 
         assert!(result.is_ok());
+
+        println!("done.");
     }
 }
 
@@ -1283,7 +1275,7 @@ mod conv_col_ultra_overflow {
 // not wasm 32 unknown
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 mod conv_relu_col_ultra_overflow {
-    use halo2_proofs::poly::commitment::{Params, ParamsProver};
+    use halo2_proofs::poly::commitment::ParamsProver;
 
     use super::*;
 
@@ -1420,15 +1412,12 @@ mod conv_relu_col_ultra_overflow {
         let strategy =
             halo2_proofs::poly::kzg::strategy::SingleStrategy::new(params.verifier_params());
         let vk = pk.get_vk();
-        let result = crate::pfsys::verify_proof_circuit_kzg(
-            params.verifier_params(),
-            proof,
-            vk,
-            strategy,
-            params.n(),
-        );
+        let result =
+            crate::pfsys::verify_proof_circuit_kzg(params.verifier_params(), proof, vk, strategy);
 
         assert!(result.is_ok());
+
+        println!("done.");
     }
 }
 
@@ -1566,280 +1555,6 @@ mod add {
     }
 }
 
-#[cfg(test)]
-mod dynamic_lookup {
-    use super::*;
-
-    const K: usize = 6;
-    const LEN: usize = 4;
-    const NUM_LOOP: usize = 5;
-
-    #[derive(Clone)]
-    struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
-        tables: [[ValTensor<F>; 2]; NUM_LOOP],
-        lookups: [[ValTensor<F>; 2]; NUM_LOOP],
-        _marker: PhantomData<F>,
-    }
-
-    impl Circuit<F> for MyCircuit<F> {
-        type Config = BaseConfig<F>;
-        type FloorPlanner = SimpleFloorPlanner;
-        type Params = TestParams;
-
-        fn without_witnesses(&self) -> Self {
-            self.clone()
-        }
-
-        fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
-            let a = VarTensor::new_advice(cs, K, 2, LEN);
-            let b = VarTensor::new_advice(cs, K, 2, LEN);
-            let c: VarTensor = VarTensor::new_advice(cs, K, 2, LEN);
-
-            let d = VarTensor::new_advice(cs, K, 1, LEN);
-            let e = VarTensor::new_advice(cs, K, 1, LEN);
-            let f: VarTensor = VarTensor::new_advice(cs, K, 1, LEN);
-
-            let _constant = VarTensor::constant_cols(cs, K, LEN * NUM_LOOP, false);
-
-            let mut config =
-                Self::Config::configure(cs, &[a.clone(), b.clone()], &c, CheckMode::SAFE);
-            config
-                .configure_dynamic_lookup(
-                    cs,
-                    &[a.clone(), b.clone(), c.clone()],
-                    &[d.clone(), e.clone(), f.clone()],
-                )
-                .unwrap();
-            config
-        }
-
-        fn synthesize(
-            &self,
-            config: Self::Config,
-            mut layouter: impl Layouter<F>,
-        ) -> Result<(), Error> {
-            layouter
-                .assign_region(
-                    || "",
-                    |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
-                        for i in 0..NUM_LOOP {
-                            layouts::dynamic_lookup(
-                                &config,
-                                &mut region,
-                                &self.lookups[i],
-                                &self.tables[i],
-                            )
-                            .map_err(|_| Error::Synthesis)?;
-                        }
-                        assert_eq!(
-                            region.dynamic_lookup_col_coord(),
-                            NUM_LOOP * self.tables[0][0].len()
-                        );
-                        assert_eq!(region.dynamic_lookup_index(), NUM_LOOP);
-
-                        Ok(())
-                    },
-                )
-                .unwrap();
-            Ok(())
-        }
-    }
-
-    #[test]
-    fn dynamiclookupcircuit() {
-        // parameters
-        let tables = (0..NUM_LOOP)
-            .map(|loop_idx| {
-                [
-                    ValTensor::from(Tensor::from(
-                        (0..LEN).map(|i| Value::known(F::from((i * loop_idx) as u64 + 1))),
-                    )),
-                    ValTensor::from(Tensor::from(
-                        (0..LEN).map(|i| Value::known(F::from((loop_idx * i * i) as u64 + 1))),
-                    )),
-                ]
-            })
-            .collect::<Vec<_>>();
-
-        let lookups = (0..NUM_LOOP)
-            .map(|loop_idx| {
-                [
-                    ValTensor::from(Tensor::from(
-                        (0..3).map(|i| Value::known(F::from((i * loop_idx) as u64 + 1))),
-                    )),
-                    ValTensor::from(Tensor::from(
-                        (0..3).map(|i| Value::known(F::from((loop_idx * i * i) as u64 + 1))),
-                    )),
-                ]
-            })
-            .collect::<Vec<_>>();
-
-        let circuit = MyCircuit::<F> {
-            tables: tables.clone().try_into().unwrap(),
-            lookups: lookups.try_into().unwrap(),
-            _marker: PhantomData,
-        };
-
-        let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied();
-
-        let lookups = (0..NUM_LOOP)
-            .map(|loop_idx| {
-                let prev_idx = if loop_idx == 0 {
-                    NUM_LOOP - 1
-                } else {
-                    loop_idx - 1
-                };
-                [
-                    ValTensor::from(Tensor::from(
-                        (0..3).map(|i| Value::known(F::from((i * prev_idx) as u64 + 1))),
-                    )),
-                    ValTensor::from(Tensor::from(
-                        (0..3).map(|i| Value::known(F::from((prev_idx * i * i) as u64 + 1))),
-                    )),
-                ]
-            })
-            .collect::<Vec<_>>();
-
-        let circuit = MyCircuit::<F> {
-            tables: tables.try_into().unwrap(),
-            lookups: lookups.try_into().unwrap(),
-            _marker: PhantomData,
-        };
-
-        let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        assert!(prover.verify().is_err());
-    }
-}
-
-#[cfg(test)]
-mod shuffle {
-    use super::*;
-
-    const K: usize = 6;
-    const LEN: usize = 4;
-    const NUM_LOOP: usize = 5;
-
-    #[derive(Clone)]
-    struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
-        inputs: [[ValTensor<F>; 1]; NUM_LOOP],
-        references: [[ValTensor<F>; 1]; NUM_LOOP],
-        _marker: PhantomData<F>,
-    }
-
-    impl Circuit<F> for MyCircuit<F> {
-        type Config = BaseConfig<F>;
-        type FloorPlanner = SimpleFloorPlanner;
-        type Params = TestParams;
-
-        fn without_witnesses(&self) -> Self {
-            self.clone()
-        }
-
-        fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
-            let a = VarTensor::new_advice(cs, K, 2, LEN);
-            let b = VarTensor::new_advice(cs, K, 2, LEN);
-            let c: VarTensor = VarTensor::new_advice(cs, K, 2, LEN);
-
-            let d = VarTensor::new_advice(cs, K, 1, LEN);
-            let e = VarTensor::new_advice(cs, K, 1, LEN);
-
-            let _constant = VarTensor::constant_cols(cs, K, LEN * NUM_LOOP, false);
-
-            let mut config =
-                Self::Config::configure(cs, &[a.clone(), b.clone()], &c, CheckMode::SAFE);
-            config
-                .configure_shuffles(cs, &[a.clone(), b.clone()], &[d.clone(), e.clone()])
-                .unwrap();
-            config
-        }
-
-        fn synthesize(
-            &self,
-            config: Self::Config,
-            mut layouter: impl Layouter<F>,
-        ) -> Result<(), Error> {
-            layouter
-                .assign_region(
-                    || "",
-                    |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
-                        for i in 0..NUM_LOOP {
-                            layouts::shuffles(
-                                &config,
-                                &mut region,
-                                &self.inputs[i],
-                                &self.references[i],
-                            )
-                            .map_err(|_| Error::Synthesis)?;
-                        }
-                        assert_eq!(
-                            region.shuffle_col_coord(),
-                            NUM_LOOP * self.references[0][0].len()
-                        );
-                        assert_eq!(region.shuffle_index(), NUM_LOOP);
-
-                        Ok(())
-                    },
-                )
-                .unwrap();
-            Ok(())
-        }
-    }
-
-    #[test]
-    fn shufflecircuit() {
-        // parameters
-        let references = (0..NUM_LOOP)
-            .map(|loop_idx| {
-                [ValTensor::from(Tensor::from((0..LEN).map(|i| {
-                    Value::known(F::from((i * loop_idx) as u64 + 1))
-                })))]
-            })
-            .collect::<Vec<_>>();
-
-        let inputs = (0..NUM_LOOP)
-            .map(|loop_idx| {
-                [ValTensor::from(Tensor::from((0..LEN).rev().map(|i| {
-                    Value::known(F::from((i * loop_idx) as u64 + 1))
-                })))]
-            })
-            .collect::<Vec<_>>();
-
-        let circuit = MyCircuit::<F> {
-            references: references.clone().try_into().unwrap(),
-            inputs: inputs.try_into().unwrap(),
-            _marker: PhantomData,
-        };
-
-        let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied();
-
-        let inputs = (0..NUM_LOOP)
-            .map(|loop_idx| {
-                let prev_idx = if loop_idx == 0 {
-                    NUM_LOOP - 1
-                } else {
-                    loop_idx - 1
-                };
-                [ValTensor::from(Tensor::from((0..LEN).rev().map(|i| {
-                    Value::known(F::from((i * prev_idx) as u64 + 1))
-                })))]
-            })
-            .collect::<Vec<_>>();
-
-        let circuit = MyCircuit::<F> {
-            references: references.try_into().unwrap(),
-            inputs: inputs.try_into().unwrap(),
-            _marker: PhantomData,
-        };
-
-        let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        assert!(prover.verify().is_err());
-    }
-}
-
 #[cfg(test)]
 mod add_with_overflow {
     use super::*;
@@ -2243,6 +1958,75 @@ mod pow {
     }
 }
 
+#[cfg(test)]
+mod pack {
+    use super::*;
+
+    const K: usize = 8;
+    const LEN: usize = 4;
+
+    #[derive(Clone)]
+    struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
+        inputs: [ValTensor<F>; 1],
+        _marker: PhantomData<F>,
+    }
+
+    impl Circuit<F> for MyCircuit<F> {
+        type Config = BaseConfig<F>;
+        type FloorPlanner = SimpleFloorPlanner;
+        type Params = TestParams;
+
+        fn without_witnesses(&self) -> Self {
+            self.clone()
+        }
+
+        fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
+            let a = VarTensor::new_advice(cs, K, 1, LEN);
+            let b = VarTensor::new_advice(cs, K, 1, LEN);
+            let output = VarTensor::new_advice(cs, K, 1, LEN);
+
+            Self::Config::configure(cs, &[a, b], &output, CheckMode::SAFE)
+        }
+
+        fn synthesize(
+            &self,
+            mut config: Self::Config,
+            mut layouter: impl Layouter<F>,
+        ) -> Result<(), Error> {
+            layouter
+                .assign_region(
+                    || "",
+                    |region| {
+                        let mut region = RegionCtx::new(region, 0, 1);
+                        config
+                            .layout(
+                                &mut region,
+                                &self.inputs.clone(),
+                                Box::new(PolyOp::Pack(2, 1)),
+                            )
+                            .map_err(|_| Error::Synthesis)
+                    },
+                )
+                .unwrap();
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn packcircuit() {
+        // parameters
+        let a = Tensor::from((0..LEN).map(|i| Value::known(F::from(i as u64 + 1))));
+
+        let circuit = MyCircuit::<F> {
+            inputs: [ValTensor::from(a)],
+            _marker: PhantomData,
+        };
+
+        let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
+        prover.assert_satisfied();
+    }
+}
+
 #[cfg(test)]
 mod matmul_relu {
     use super::*;
@@ -2336,6 +2120,148 @@ mod matmul_relu {
     }
 }
 
+#[cfg(test)]
+mod rangecheckpercent {
+    use crate::circuit::Tolerance;
+    use crate::{circuit, tensor::Tensor};
+    use halo2_proofs::{
+        circuit::{Layouter, SimpleFloorPlanner, Value},
+        dev::MockProver,
+        plonk::{Circuit, ConstraintSystem, Error},
+    };
+
+    const RANGE: f32 = 1.0; // 1 percent error tolerance
+    const K: usize = 18;
+    const LEN: usize = 1;
+    const SCALE: usize = i128::pow(2, 7) as usize;
+
+    use super::*;
+
+    #[derive(Clone)]
+    struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
+        input: ValTensor<F>,
+        output: ValTensor<F>,
+        _marker: PhantomData<F>,
+    }
+
+    impl Circuit<F> for MyCircuit<F> {
+        type Config = BaseConfig<F>;
+        type FloorPlanner = SimpleFloorPlanner;
+        type Params = TestParams;
+
+        fn without_witnesses(&self) -> Self {
+            self.clone()
+        }
+
+        fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
+            let scale = utils::F32(SCALE as f32);
+            let a = VarTensor::new_advice(cs, K, 1, LEN);
+            let b = VarTensor::new_advice(cs, K, 1, LEN);
+            let output = VarTensor::new_advice(cs, K, 1, LEN);
+            let mut config =
+                Self::Config::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::SAFE);
+            // set up a new GreaterThan and Recip tables
+            let nl = &LookupOp::GreaterThan {
+                a: circuit::utils::F32((RANGE * SCALE.pow(2) as f32) / 100.0),
+            };
+            config
+                .configure_lookup(cs, &b, &output, &a, (-32768, 32768), K, nl)
+                .unwrap();
+
+            config
+                .configure_lookup(
+                    cs,
+                    &b,
+                    &output,
+                    &a,
+                    (-32768, 32768),
+                    K,
+                    &LookupOp::Recip {
+                        input_scale: scale,
+                        output_scale: scale,
+                    },
+                )
+                .unwrap();
+            config
+        }
+
+        fn synthesize(
+            &self,
+            mut config: Self::Config,
+            mut layouter: impl Layouter<F>,
+        ) -> Result<(), Error> {
+            config.layout_tables(&mut layouter).unwrap();
+            layouter
+                .assign_region(
+                    || "",
+                    |region| {
+                        let mut region = RegionCtx::new(region, 0, 1);
+                        config
+                            .layout(
+                                &mut region,
+                                &[self.output.clone(), self.input.clone()],
+                                Box::new(HybridOp::RangeCheck(Tolerance {
+                                    val: RANGE,
+                                    scale: SCALE.into(),
+                                })),
+                            )
+                            .map_err(|_| Error::Synthesis)
+                    },
+                )
+                .unwrap();
+            Ok(())
+        }
+    }
+
+    #[test]
+    #[allow(clippy::assertions_on_constants)]
+    fn test_range_check_percent() {
+        // Successful cases
+        {
+            let inp = Tensor::new(Some(&[Value::<F>::known(F::from(100_u64))]), &[1]).unwrap();
+            let out = Tensor::new(Some(&[Value::<F>::known(F::from(101_u64))]), &[1]).unwrap();
+            let circuit = MyCircuit::<F> {
+                input: ValTensor::from(inp),
+                output: ValTensor::from(out),
+                _marker: PhantomData,
+            };
+            let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
+            prover.assert_satisfied();
+        }
+        {
+            let inp = Tensor::new(Some(&[Value::<F>::known(F::from(200_u64))]), &[1]).unwrap();
+            let out = Tensor::new(Some(&[Value::<F>::known(F::from(199_u64))]), &[1]).unwrap();
+            let circuit = MyCircuit::<F> {
+                input: ValTensor::from(inp),
+                output: ValTensor::from(out),
+                _marker: PhantomData,
+            };
+            let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
+            prover.assert_satisfied();
+        }
+
+        // Unsuccessful case
+        {
+            let inp = Tensor::new(Some(&[Value::<F>::known(F::from(100_u64))]), &[1]).unwrap();
+            let out = Tensor::new(Some(&[Value::<F>::known(F::from(102_u64))]), &[1]).unwrap();
+            let circuit = MyCircuit::<F> {
+                input: ValTensor::from(inp),
+                output: ValTensor::from(out),
+                _marker: PhantomData,
+            };
+            let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
+            match prover.verify() {
+                Ok(_) => {
+                    assert!(false)
+                }
+                Err(_) => {
+                    assert!(true)
+                }
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod relu {
     use super::*;
@@ -2417,7 +2343,7 @@ mod lookup_ultra_overflow {
     use halo2_proofs::{
         circuit::{Layouter, SimpleFloorPlanner, Value},
         plonk::{Circuit, ConstraintSystem, Error},
-        poly::commitment::{Params, ParamsProver},
+        poly::commitment::ParamsProver,
     };
 
     #[derive(Clone)]
@@ -2521,14 +2447,121 @@ mod lookup_ultra_overflow {
         let strategy =
             halo2_proofs::poly::kzg::strategy::SingleStrategy::new(params.verifier_params());
         let vk = pk.get_vk();
-        let result = crate::pfsys::verify_proof_circuit_kzg(
-            params.verifier_params(),
-            proof,
-            vk,
-            strategy,
-            params.n(),
-        );
+        let result =
+            crate::pfsys::verify_proof_circuit_kzg(params.verifier_params(), proof, vk, strategy);
 
         assert!(result.is_ok());
+
+        println!("done.");
+    }
+}
+
+#[cfg(test)]
+mod softmax {
+
+    use super::*;
+    use halo2_proofs::{
+        circuit::{Layouter, SimpleFloorPlanner, Value},
+        dev::MockProver,
+        plonk::{Circuit, ConstraintSystem, Error},
+    };
+
+    const K: usize = 18;
+    const LEN: usize = 3;
+    const SCALE: f32 = 128.0;
+
+    #[derive(Clone)]
+    struct SoftmaxCircuit<F: PrimeField + TensorType + PartialOrd> {
+        pub input: ValTensor<F>,
+        _marker: PhantomData<F>,
+    }
+
+    impl Circuit<F> for SoftmaxCircuit<F> {
+        type Config = BaseConfig<F>;
+        type FloorPlanner = SimpleFloorPlanner;
+        type Params = TestParams;
+
+        fn without_witnesses(&self) -> Self {
+            self.clone()
+        }
+        fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
+            let a = VarTensor::new_advice(cs, K, 1, LEN);
+            let b = VarTensor::new_advice(cs, K, 1, LEN);
+            let output = VarTensor::new_advice(cs, K, 1, LEN);
+            let mut config = Self::Config::configure(cs, &[a, b], &output, CheckMode::SAFE);
+            let advices = (0..3)
+                .map(|_| VarTensor::new_advice(cs, K, 1, LEN))
+                .collect::<Vec<_>>();
+
+            config
+                .configure_lookup(
+                    cs,
+                    &advices[0],
+                    &advices[1],
+                    &advices[2],
+                    (-32768, 32768),
+                    K,
+                    &LookupOp::Exp {
+                        scale: SCALE.into(),
+                    },
+                )
+                .unwrap();
+            config
+                .configure_lookup(
+                    cs,
+                    &advices[0],
+                    &advices[1],
+                    &advices[2],
+                    (-32768, 32768),
+                    K,
+                    &LookupOp::Recip {
+                        input_scale: SCALE.into(),
+                        output_scale: SCALE.into(),
+                    },
+                )
+                .unwrap();
+            config
+        }
+
+        fn synthesize(
+            &self,
+            mut config: Self::Config,
+            mut layouter: impl Layouter<F>,
+        ) -> Result<(), Error> {
+            config.layout_tables(&mut layouter).unwrap();
+            layouter
+                .assign_region(
+                    || "",
+                    |region| {
+                        let mut region = RegionCtx::new(region, 0, 1);
+                        let _output = config
+                            .layout(
+                                &mut region,
+                                &[self.input.clone()],
+                                Box::new(HybridOp::Softmax {
+                                    scale: SCALE.into(),
+                                    axes: vec![0],
+                                }),
+                            )
+                            .unwrap();
+                        Ok(())
+                    },
+                )
+                .unwrap();
+
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn softmax_circuit() {
+        let input = Tensor::from((0..LEN).map(|i| Value::known(F::from(i as u64 + 1))));
+
+        let circuit = SoftmaxCircuit::<F> {
+            input: ValTensor::from(input),
+            _marker: PhantomData,
+        };
+        let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
+        prover.assert_satisfied();
     }
 }

src/commands.rs

@@ -1,4 +1,4 @@
-use clap::{Parser, Subcommand};
+use clap::{Parser, Subcommand, ValueEnum};
 #[cfg(not(target_arch = "wasm32"))]
 use ethers::types::H160;
 #[cfg(feature = "python-bindings")]
@@ -9,9 +9,8 @@ use pyo3::{
     types::PyString,
 };
 use serde::{Deserialize, Serialize};
+use std::error::Error;
 use std::path::PathBuf;
-use std::{error::Error, str::FromStr};
-use tosubcommand::{ToFlags, ToSubcommand};
 
 use crate::{pfsys::ProofType, RunArgs};
 
@@ -77,7 +76,7 @@ pub const DEFAULT_CALIBRATION_FILE: &str = "calibration.json";
 /// Default lookup safety margin
 pub const DEFAULT_LOOKUP_SAFETY_MARGIN: &str = "2";
 /// Default Compress selectors
-pub const DEFAULT_DISABLE_SELECTOR_COMPRESSION: &str = "false";
+pub const DEFAULT_COMPRESS_SELECTORS: &str = "false";
 /// Default render vk seperately
 pub const DEFAULT_RENDER_VK_SEPERATELY: &str = "false";
 /// Default VK sol path
@@ -86,11 +85,15 @@ pub const DEFAULT_VK_SOL: &str = "vk.sol";
 pub const DEFAULT_VK_ABI: &str = "vk.abi";
 /// Default scale rebase multipliers for calibration
 pub const DEFAULT_SCALE_REBASE_MULTIPLIERS: &str = "1,2,10";
-/// Default use reduced srs for verification
-pub const DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION: &str = "false";
-/// Default only check for range check rebase
-pub const DEFAULT_ONLY_RANGE_CHECK_REBASE: &str = "false";
 
+impl std::fmt::Display for TranscriptType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.to_possible_value()
+            .expect("no values are skipped")
+            .get_name()
+            .fmt(f)
+    }
+}
 #[cfg(feature = "python-bindings")]
 /// Converts TranscriptType into a PyObject (Required for TranscriptType to be compatible with Python)
 impl IntoPy<PyObject> for TranscriptType {
@@ -135,27 +138,17 @@ impl Default for CalibrationTarget {
     }
 }
 
-impl std::fmt::Display for CalibrationTarget {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                CalibrationTarget::Resources { col_overflow: true } => {
-                    "resources/col-overflow".to_string()
-                }
-                CalibrationTarget::Resources {
-                    col_overflow: false,
-                } => "resources".to_string(),
-                CalibrationTarget::Accuracy => "accuracy".to_string(),
+impl ToString for CalibrationTarget {
+    fn to_string(&self) -> String {
+        match self {
+            CalibrationTarget::Resources { col_overflow: true } => {
+                "resources/col-overflow".to_string()
             }
-        )
-    }
-}
-
-impl ToFlags for CalibrationTarget {
-    fn to_flags(&self) -> Vec<String> {
-        vec![format!("{}", self)]
+            CalibrationTarget::Resources {
+                col_overflow: false,
+            } => "resources".to_string(),
+            CalibrationTarget::Accuracy => "accuracy".to_string(),
+        }
     }
 }
 
@@ -176,36 +169,6 @@ impl From<&str> for CalibrationTarget {
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, PartialOrd)]
-/// wrapper for H160 to make it easy to parse into flag vals
-pub struct H160Flag {
-    inner: H160,
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl From<H160Flag> for H160 {
-    fn from(val: H160Flag) -> H160 {
-        val.inner
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl ToFlags for H160Flag {
-    fn to_flags(&self) -> Vec<String> {
-        vec![format!("{:#x}", self.inner)]
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl From<&str> for H160Flag {
-    fn from(s: &str) -> Self {
-        Self {
-            inner: H160::from_str(s).unwrap(),
-        }
-    }
-}
-
 #[cfg(feature = "python-bindings")]
 /// Converts CalibrationTarget into a PyObject (Required for CalibrationTarget to be compatible with Python)
 impl IntoPy<PyObject> for CalibrationTarget {
@@ -238,7 +201,7 @@ impl<'source> FromPyObject<'source> for CalibrationTarget {
         }
     }
 }
-// not wasm
+
 use lazy_static::lazy_static;
 
 // if CARGO VERSION is 0.0.0 replace with "source - no compatibility guaranteed"
@@ -279,7 +242,7 @@ impl Cli {
 }
 
 #[allow(missing_docs)]
-#[derive(Debug, Subcommand, Clone, Deserialize, Serialize, PartialEq, PartialOrd, ToSubcommand)]
+#[derive(Debug, Subcommand, Clone, Deserialize, Serialize, PartialEq, PartialOrd)]
 pub enum Commands {
     #[cfg(feature = "empty-cmd")]
     /// Creates an empty buffer
@@ -294,6 +257,21 @@ pub enum Commands {
         args: RunArgs,
     },
 
+    #[cfg(feature = "render")]
+    /// Renders the model circuit to a .png file. For an overview of how to interpret these plots, see https://zcash.github.io/halo2/user/dev-tools.html
+    #[command(arg_required_else_help = true)]
+    RenderCircuit {
+        /// The path to the .onnx model file
+        #[arg(short = 'M', long)]
+        model: PathBuf,
+        /// Path to save the .png circuit render
+        #[arg(short = 'O', long)]
+        output: PathBuf,
+        /// proving arguments
+        #[clap(flatten)]
+        args: RunArgs,
+    },
+
     /// Generates the witness from an input file.
     GenWitness {
         /// The path to the .json data file
@@ -358,9 +336,9 @@ pub enum Commands {
         /// max logrows to use for calibration, 26 is the max public SRS size
         #[arg(long)]
         max_logrows: Option<u32>,
-        // whether to only range check rebases (instead of trying both range check and lookup)
-        #[arg(long, default_value = DEFAULT_ONLY_RANGE_CHECK_REBASE)]
-        only_range_check_rebase: bool,
+        // whether to fix the div_rebasing value truthiness during calibration. this changes how we rebase
+        #[arg(long)]
+        div_rebasing: Option<bool>,
     },
 
     /// Generates a dummy SRS
@@ -387,6 +365,9 @@ pub enum Commands {
         /// Number of logrows to use for srs. Overrides settings_path if specified.
         #[arg(long, default_value = None)]
         logrows: Option<u32>,
+        /// Check mode for SRS. Verifies downloaded srs is valid. Set to unsafe for speed.
+        #[arg(long, default_value = DEFAULT_CHECKMODE)]
+        check: CheckMode,
     },
     /// Loads model and input and runs mock prover (for testing)
     Mock {
@@ -432,8 +413,8 @@ pub enum Commands {
         #[arg(long, default_value = DEFAULT_SPLIT)]
         split_proofs: bool,
         /// compress selectors
-        #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION)]
-        disable_selector_compression: bool,
+        #[arg(long, default_value = DEFAULT_COMPRESS_SELECTORS)]
+        compress_selectors: bool,
     },
     /// Aggregates proofs :)
     Aggregate {
@@ -453,7 +434,7 @@ pub enum Commands {
             long,
             require_equals = true,
             num_args = 0..=1,
-            default_value_t = TranscriptType::default(),
+            default_value_t = TranscriptType::EVM,
             value_enum
         )]
         transcript: TranscriptType,
@@ -497,8 +478,8 @@ pub enum Commands {
         #[arg(short = 'W', long)]
         witness: Option<PathBuf>,
         /// compress selectors
-        #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION)]
-        disable_selector_compression: bool,
+        #[arg(long, default_value = DEFAULT_COMPRESS_SELECTORS)]
+        compress_selectors: bool,
     },
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -508,13 +489,13 @@ pub enum Commands {
         #[arg(short = 'W', long, default_value = DEFAULT_WITNESS)]
         witness: PathBuf,
         /// The path to the compiled model file (generated using the compile-circuit command)
-        #[arg(short = 'M', long)]
+        #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT)]
         compiled_circuit: PathBuf,
         #[arg(
             long,
             require_equals = true,
             num_args = 0..=1,
-            default_value_t = TranscriptType::default(),
+            default_value_t = TranscriptType::EVM,
             value_enum
         )]
         transcript: TranscriptType,
@@ -522,13 +503,13 @@ pub enum Commands {
         #[arg(long, default_value = DEFAULT_FUZZ_RUNS)]
         num_runs: usize,
         /// compress selectors
-        #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION)]
-        disable_selector_compression: bool,
+        #[arg(long, default_value = DEFAULT_COMPRESS_SELECTORS)]
+        compress_selectors: bool,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Deploys a test contact that the data attester reads from and creates a data attestation formatted input.json file that contains call data information
     #[command(arg_required_else_help = true)]
-    SetupTestEvmData {
+    SetupTestEVMData {
         /// The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
         #[arg(short = 'D', long)]
         data: PathBuf,
@@ -556,7 +537,7 @@ pub enum Commands {
     TestUpdateAccountCalls {
         /// The path to the verifier contract's address
         #[arg(long)]
-        addr: H160Flag,
+        addr: H160,
         /// The path to the .json data file.
         #[arg(short = 'D', long)]
         data: PathBuf,
@@ -606,9 +587,9 @@ pub enum Commands {
         check_mode: CheckMode,
     },
     #[cfg(not(target_arch = "wasm32"))]
-    /// Creates an Evm verifier for a single proof
+    /// Creates an EVM verifier for a single proof
     #[command(name = "create-evm-verifier")]
-    CreateEvmVerifier {
+    CreateEVMVerifier {
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
@@ -631,9 +612,9 @@ pub enum Commands {
         render_vk_seperately: bool,
     },
     #[cfg(not(target_arch = "wasm32"))]
-    /// Creates an Evm verifier for a single proof
+    /// Creates an EVM verifier for a single proof
     #[command(name = "create-evm-vk")]
-    CreateEvmVK {
+    CreateEVMVK {
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
@@ -651,9 +632,9 @@ pub enum Commands {
         abi_path: PathBuf,
     },
     #[cfg(not(target_arch = "wasm32"))]
-    /// Creates an Evm verifier that attests to on-chain inputs for a single proof
+    /// Creates an EVM verifier that attests to on-chain inputs for a single proof
     #[command(name = "create-evm-da")]
-    CreateEvmDataAttestation {
+    CreateEVMDataAttestation {
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
         settings_path: PathBuf,
@@ -673,9 +654,9 @@ pub enum Commands {
     },
 
     #[cfg(not(target_arch = "wasm32"))]
-    /// Creates an Evm verifier for an aggregate proof
+    /// Creates an EVM verifier for an aggregate proof
     #[command(name = "create-evm-verifier-aggr")]
-    CreateEvmVerifierAggr {
+    CreateEVMVerifierAggr {
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
@@ -714,9 +695,6 @@ pub enum Commands {
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
-        /// Reduce SRS logrows to the number of instances rather than the number of logrows used for proofs (only works if the srs were generated in the same ceremony)
-        #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION)]
-        reduced_srs: bool,
     },
     /// Verifies an aggregate proof, returning accept or reject
     VerifyAggr {
@@ -798,23 +776,31 @@ pub enum Commands {
         private_key: Option<String>,
     },
     #[cfg(not(target_arch = "wasm32"))]
-    /// Verifies a proof using a local Evm executor, returning accept or reject
+    /// Verifies a proof using a local EVM executor, returning accept or reject
     #[command(name = "verify-evm")]
-    VerifyEvm {
+    VerifyEVM {
         /// The path to the proof file (generated using the prove command)
         #[arg(long, default_value = DEFAULT_PROOF)]
         proof_path: PathBuf,
         /// The path to verifier contract's address
         #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS)]
-        addr_verifier: H160Flag,
+        addr_verifier: H160,
         /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
         #[arg(short = 'U', long)]
         rpc_url: Option<String>,
         /// does the verifier use data attestation ?
         #[arg(long)]
-        addr_da: Option<H160Flag>,
+        addr_da: Option<H160>,
         // is the vk rendered seperately, if so specify an address
         #[arg(long)]
-        addr_vk: Option<H160Flag>,
+        addr_vk: Option<H160>,
+    },
+
+    /// Print the proof in hexadecimal
+    #[command(name = "print-proof-hex")]
+    PrintProofHex {
+        /// The path to the proof file
+        #[arg(long, default_value = DEFAULT_PROOF)]
+        proof_path: PathBuf,
     },
 }

src/execute.rs

@@ -3,8 +3,6 @@ use crate::circuit::CheckMode;
 use crate::commands::CalibrationTarget;
 use crate::commands::Commands;
 #[cfg(not(target_arch = "wasm32"))]
-use crate::commands::H160Flag;
-#[cfg(not(target_arch = "wasm32"))]
 use crate::eth::{deploy_contract_via_solidity, deploy_da_verifier_via_solidity};
 #[cfg(not(target_arch = "wasm32"))]
 #[allow(unused_imports)]
@@ -23,7 +21,8 @@ use crate::pfsys::{create_proof_circuit_kzg, verify_proof_circuit_kzg};
 use crate::pfsys::{save_vk, srs::*};
 use crate::tensor::TensorError;
 use crate::RunArgs;
-#[cfg(unix)]
+#[cfg(not(target_arch = "wasm32"))]
+use ethers::types::H160;
 use gag::Gag;
 use halo2_proofs::dev::VerifyFailure;
 use halo2_proofs::poly::commitment::Params;
@@ -48,6 +47,8 @@ use log::debug;
 use log::{info, trace, warn};
 #[cfg(not(target_arch = "wasm32"))]
 use maybe_rayon::prelude::{IntoParallelIterator, ParallelIterator};
+#[cfg(feature = "render")]
+use plotters::prelude::*;
 #[cfg(not(target_arch = "wasm32"))]
 use rand::Rng;
 use std::error::Error;
@@ -62,11 +63,7 @@ use std::process::Command;
 use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
 #[cfg(not(target_arch = "wasm32"))]
 use std::sync::OnceLock;
-
 #[cfg(not(target_arch = "wasm32"))]
-use crate::EZKL_BUF_CAPACITY;
-#[cfg(not(target_arch = "wasm32"))]
-use std::io::BufWriter;
 use std::time::Duration;
 use tabled::Tabled;
 use thiserror::Error;
@@ -143,13 +140,13 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             compiled_circuit,
             transcript,
             num_runs,
-            disable_selector_compression,
+            compress_selectors,
         } => fuzz(
             compiled_circuit,
             witness,
             transcript,
             num_runs,
-            disable_selector_compression,
+            compress_selectors,
         ),
         Commands::GenSrs { srs_path, logrows } => gen_srs_cmd(srs_path, logrows as u32),
         #[cfg(not(target_arch = "wasm32"))]
@@ -157,8 +154,15 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             srs_path,
             settings_path,
             logrows,
-        } => get_srs_cmd(srs_path, settings_path, logrows).await,
+            check,
+        } => get_srs_cmd(srs_path, settings_path, logrows, check).await,
         Commands::Table { model, args } => table(model, args),
+        #[cfg(feature = "render")]
+        Commands::RenderCircuit {
+            model,
+            output,
+            args,
+        } => render(model, output, args),
         Commands::GenSettings {
             model,
             settings_path,
@@ -174,7 +178,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             scales,
             scale_rebase_multiplier,
             max_logrows,
-            only_range_check_rebase,
+            div_rebasing,
         } => calibrate(
             model,
             data,
@@ -183,7 +187,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             lookup_safety_margin,
             scales,
             scale_rebase_multiplier,
-            only_range_check_rebase,
+            div_rebasing,
             max_logrows,
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
@@ -198,7 +202,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             .map(|e| serde_json::to_string(&e).unwrap()),
         Commands::Mock { model, witness } => mock(model, witness),
         #[cfg(not(target_arch = "wasm32"))]
-        Commands::CreateEvmVerifier {
+        Commands::CreateEVMVerifier {
             vk_path,
             srs_path,
             settings_path,
@@ -213,7 +217,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             abi_path,
             render_vk_seperately,
         ),
-        Commands::CreateEvmVK {
+        Commands::CreateEVMVK {
             vk_path,
             srs_path,
             settings_path,
@@ -221,14 +225,14 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             abi_path,
         } => create_evm_vk(vk_path, srs_path, settings_path, sol_code_path, abi_path),
         #[cfg(not(target_arch = "wasm32"))]
-        Commands::CreateEvmDataAttestation {
+        Commands::CreateEVMDataAttestation {
             settings_path,
             sol_code_path,
             abi_path,
             data,
         } => create_evm_data_attestation(settings_path, sol_code_path, abi_path, data),
         #[cfg(not(target_arch = "wasm32"))]
-        Commands::CreateEvmVerifierAggr {
+        Commands::CreateEVMVerifierAggr {
             vk_path,
             srs_path,
             sol_code_path,
@@ -256,17 +260,17 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             vk_path,
             pk_path,
             witness,
-            disable_selector_compression,
+            compress_selectors,
         } => setup(
             compiled_circuit,
             srs_path,
             vk_path,
             pk_path,
             witness,
-            disable_selector_compression,
+            compress_selectors,
         ),
         #[cfg(not(target_arch = "wasm32"))]
-        Commands::SetupTestEvmData {
+        Commands::SetupTestEVMData {
             data,
             compiled_circuit,
             test_data,
@@ -327,7 +331,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             srs_path,
             logrows,
             split_proofs,
-            disable_selector_compression,
+            compress_selectors,
         } => setup_aggregate(
             sample_snarks,
             vk_path,
@@ -335,7 +339,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             srs_path,
             logrows,
             split_proofs,
-            disable_selector_compression,
+            compress_selectors,
         ),
         Commands::Aggregate {
             proof_path,
@@ -362,8 +366,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             settings_path,
             vk_path,
             srs_path,
-            reduced_srs,
-        } => verify(proof_path, settings_path, vk_path, srs_path, reduced_srs)
+        } => verify(proof_path, settings_path, vk_path, srs_path)
             .map(|e| serde_json::to_string(&e).unwrap()),
         Commands::VerifyAggr {
             proof_path,
@@ -430,13 +433,14 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             .await
         }
         #[cfg(not(target_arch = "wasm32"))]
-        Commands::VerifyEvm {
+        Commands::VerifyEVM {
             proof_path,
             addr_verifier,
             rpc_url,
             addr_da,
             addr_vk,
         } => verify_evm(proof_path, addr_verifier, rpc_url, addr_da, addr_vk).await,
+        Commands::PrintProofHex { proof_path } => print_proof_hex(proof_path),
     }
 }
 
@@ -482,29 +486,11 @@ async fn fetch_srs(uri: &str) -> Result<Vec<u8>, Box<dyn Error>> {
     Ok(std::mem::take(&mut buf))
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) fn get_file_hash(path: &PathBuf) -> Result<String, Box<dyn Error>> {
-    use std::io::Read;
-    let file = std::fs::File::open(path)?;
-    let mut reader = std::io::BufReader::new(file);
-    let mut buffer = vec![];
-    let bytes_read = reader.read_to_end(&mut buffer)?;
-    info!(
-        "read {} bytes from file (vector of len = {})",
-        bytes_read,
-        buffer.len()
-    );
-
-    let hash = sha256::digest(buffer);
-    info!("file hash: {}", hash);
-
-    Ok(hash)
-}
-
 #[cfg(not(target_arch = "wasm32"))]
 fn check_srs_hash(logrows: u32, srs_path: Option<PathBuf>) -> Result<String, Box<dyn Error>> {
     let path = get_srs_path(logrows, srs_path);
-    let hash = get_file_hash(&path)?;
+    let hash = sha256::digest(std::fs::read(path.clone())?);
+    info!("SRS hash: {}", hash);
 
     let predefined_hash = match { crate::srs_sha::PUBLIC_SRS_SHA256_HASHES.get(&logrows) } {
         Some(h) => h,
@@ -528,6 +514,7 @@ pub(crate) async fn get_srs_cmd(
     srs_path: Option<PathBuf>,
     settings_path: Option<PathBuf>,
     logrows: Option<u32>,
+    check_mode: CheckMode,
 ) -> Result<String, Box<dyn Error>> {
     // logrows overrides settings
 
@@ -555,21 +542,18 @@ pub(crate) async fn get_srs_cmd(
         let srs_uri = format!("{}{}", PUBLIC_SRS_URL, k);
         let mut reader = Cursor::new(fetch_srs(&srs_uri).await?);
         // check the SRS
-        #[cfg(not(target_arch = "wasm32"))]
-        let pb = init_spinner();
-        #[cfg(not(target_arch = "wasm32"))]
-        pb.set_message("Validating SRS (this may take a while) ...");
-        let params = ParamsKZG::<Bn256>::read(&mut reader)?;
-        #[cfg(not(target_arch = "wasm32"))]
-        pb.finish_with_message("SRS validated.");
+        if matches!(check_mode, CheckMode::SAFE) {
+            #[cfg(not(target_arch = "wasm32"))]
+            let pb = init_spinner();
+            #[cfg(not(target_arch = "wasm32"))]
+            pb.set_message("Validating SRS (this may take a while) ...");
+            ParamsKZG::<Bn256>::read(&mut reader)?;
+            #[cfg(not(target_arch = "wasm32"))]
+            pb.finish_with_message("SRS validated");
+        }
 
-        info!("Saving SRS to disk...");
         let mut file = std::fs::File::create(get_srs_path(k, srs_path.clone()))?;
-        let mut buffer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, &mut file);
-        params.write(&mut buffer)?;
-
-        info!("Saved SRS to disk.");
-
+        file.write_all(reader.get_ref())?;
         info!("SRS downloaded");
     } else {
         info!("SRS already exists at that path");
@@ -628,7 +612,7 @@ pub(crate) async fn gen_witness(
 
     let start_time = Instant::now();
 
-    let witness = circuit.forward(&mut input, vk.as_ref(), srs.as_ref(), false)?;
+    let witness = circuit.forward(&mut input, vk.as_ref(), srs.as_ref())?;
 
     // print each variable tuple (symbol, value) as symbol=value
     trace!(
@@ -644,7 +628,7 @@ pub(crate) async fn gen_witness(
     );
 
     if let Some(output_path) = output {
-        witness.save(output_path)?;
+        serde_json::to_writer(&File::create(output_path)?, &witness)?;
     }
 
     // print the witness in debug
@@ -742,11 +726,11 @@ impl AccuracyResults {
             let percentage_error = error.enum_map(|i, x| Ok::<_, TensorError>(x / original[i]))?;
             let abs_percentage_error = percentage_error.map(|x| x.abs());
 
-            errors.extend(error);
-            abs_errors.extend(abs_error);
-            squared_errors.extend(squared_error);
-            percentage_errors.extend(percentage_error);
-            abs_percentage_errors.extend(abs_percentage_error);
+            errors.extend(error.into_iter());
+            abs_errors.extend(abs_error.into_iter());
+            squared_errors.extend(squared_error.into_iter());
+            percentage_errors.extend(percentage_error.into_iter());
+            abs_percentage_errors.extend(abs_percentage_error.into_iter());
         }
 
         let mean_percent_error =
@@ -796,7 +780,6 @@ impl AccuracyResults {
 /// Calibrate the circuit parameters to a given a dataset
 #[cfg(not(target_arch = "wasm32"))]
 #[allow(trivial_casts)]
-#[allow(clippy::too_many_arguments)]
 pub(crate) fn calibrate(
     model_path: PathBuf,
     data: PathBuf,
@@ -805,7 +788,7 @@ pub(crate) fn calibrate(
     lookup_safety_margin: i128,
     scales: Option<Vec<crate::Scale>>,
     scale_rebase_multiplier: Vec<u32>,
-    only_range_check_rebase: bool,
+    div_rebasing: Option<bool>,
     max_logrows: Option<u32>,
 ) -> Result<GraphSettings, Box<dyn Error>> {
     use std::collections::HashMap;
@@ -816,8 +799,18 @@ pub(crate) fn calibrate(
     let settings = GraphSettings::load(&settings_path)?;
     // now retrieve the run args
     // we load the model to get the input and output shapes
+    // check if gag already exists
+
+    #[cfg(unix)]
+    let _r = match Gag::stdout() {
+        Ok(r) => Some(r),
+        Err(_) => None,
+    };
 
     let model = Model::from_run_args(&settings.run_args, &model_path)?;
+    // drop the gag
+    #[cfg(unix)]
+    std::mem::drop(_r);
 
     let chunks = data.split_into_batches(model.graph.input_shapes()?)?;
     info!("num of calibration batches: {}", chunks.len());
@@ -833,11 +826,14 @@ pub(crate) fn calibrate(
     let range = if let Some(scales) = scales {
         scales
     } else {
-        (11..14).collect::<Vec<crate::Scale>>()
+        match target {
+            CalibrationTarget::Resources { .. } => (8..10).collect::<Vec<crate::Scale>>(),
+            CalibrationTarget::Accuracy => (10..14).collect::<Vec<crate::Scale>>(),
+        }
     };
 
-    let div_rebasing = if only_range_check_rebase {
-        vec![false]
+    let div_rebasing = if let Some(div_rebasing) = div_rebasing {
+        vec![div_rebasing]
     } else {
         vec![true, false]
     };
@@ -896,12 +892,17 @@ pub(crate) fn calibrate(
             input_scale, param_scale, scale_rebase_multiplier, div_rebasing
         ));
 
-        let key = (
-            input_scale,
-            param_scale,
-            scale_rebase_multiplier,
-            div_rebasing,
-        );
+        #[cfg(unix)]
+        let _r = match Gag::stdout() {
+            Ok(r) => Some(r),
+            Err(_) => None,
+        };
+        #[cfg(unix)]
+        let _q = match Gag::stderr() {
+            Ok(r) => Some(r),
+            Err(_) => None,
+        };
+        let key = (input_scale, param_scale, scale_rebase_multiplier);
         forward_pass_res.insert(key, vec![]);
 
         let local_run_args = RunArgs {
@@ -912,27 +913,20 @@ pub(crate) fn calibrate(
             ..settings.run_args.clone()
         };
 
-        // if unix get a gag
-        #[cfg(unix)]
-        let _r = match Gag::stdout() {
-            Ok(g) => Some(g),
-            _ => None,
-        };
-        #[cfg(unix)]
-        let _g = match Gag::stderr() {
-            Ok(g) => Some(g),
-            _ => None,
-        };
-
         let mut circuit = match GraphCircuit::from_run_args(&local_run_args, &model_path) {
             Ok(c) => c,
             Err(e) => {
+                // drop the gag
+                #[cfg(unix)]
+                std::mem::drop(_r);
+                #[cfg(unix)]
+                std::mem::drop(_q);
                 debug!("circuit creation from run args failed: {:?}", e);
                 continue;
             }
         };
 
-        let forward_res = chunks
+        chunks
             .iter()
             .map(|chunk| {
                 let chunk = chunk.clone();
@@ -942,7 +936,7 @@ pub(crate) fn calibrate(
                     .map_err(|e| format!("failed to load circuit inputs: {}", e))?;
 
                 let forward_res = circuit
-                    .forward(&mut data.clone(), None, None, true)
+                    .forward(&mut data.clone(), None, None)
                     .map_err(|e| format!("failed to forward: {}", e))?;
 
                 // push result to the hashmap
@@ -953,46 +947,37 @@ pub(crate) fn calibrate(
 
                 Ok(()) as Result<(), String>
             })
-            .collect::<Result<Vec<()>, String>>();
+            .collect::<Result<Vec<()>, String>>()?;
 
-        match forward_res {
-            Ok(_) => (),
-            // typically errors will be due to the circuit overflowing the i128 limit
-            Err(e) => {
-                debug!("forward pass failed: {:?}", e);
-                continue;
-            }
-        }
-
-        // drop the gag
-        #[cfg(unix)]
-        drop(_r);
-        #[cfg(unix)]
-        drop(_g);
-
-        let result = forward_pass_res.get(&key).ok_or("key not found")?;
-
-        let min_lookup_range = result
+        let min_lookup_range = forward_pass_res
+            .get(&key)
+            .unwrap()
             .iter()
             .map(|x| x.min_lookup_inputs)
             .min()
             .unwrap_or(0);
 
-        let max_lookup_range = result
+        let max_lookup_range = forward_pass_res
+            .get(&key)
+            .unwrap()
             .iter()
             .map(|x| x.max_lookup_inputs)
             .max()
             .unwrap_or(0);
 
-        let max_range_size = result.iter().map(|x| x.max_range_size).max().unwrap_or(0);
-
-        let res = circuit.calc_min_logrows(
-            (min_lookup_range, max_lookup_range),
-            max_range_size,
+        let res = circuit.calibrate_from_min_max(
+            min_lookup_range,
+            max_lookup_range,
             max_logrows,
             lookup_safety_margin,
         );
 
+        // drop the gag
+        #[cfg(unix)]
+        std::mem::drop(_r);
+        #[cfg(unix)]
+        std::mem::drop(_q);
+
         if res.is_ok() {
             let new_settings = circuit.settings().clone();
 
@@ -1105,7 +1090,6 @@ pub(crate) fn calibrate(
             best_params.run_args.input_scale,
             best_params.run_args.param_scale,
             best_params.run_args.scale_rebase_multiplier,
-            best_params.run_args.div_rebasing,
         ))
         .ok_or("no params found")?
         .iter()
@@ -1188,6 +1172,39 @@ pub(crate) fn mock(
     Ok(String::new())
 }
 
+pub(crate) fn print_proof_hex(proof_path: PathBuf) -> Result<String, Box<dyn Error>> {
+    let proof = Snark::load::<KZGCommitmentScheme<Bn256>>(&proof_path)?;
+    for instance in proof.instances {
+        println!("{:?}", instance);
+    }
+    let hex_str = hex::encode(proof.proof);
+    info!("0x{}", hex_str);
+    Ok(format!("0x{}", hex_str))
+}
+
+#[cfg(feature = "render")]
+pub(crate) fn render(
+    model: PathBuf,
+    output: PathBuf,
+    args: RunArgs,
+) -> Result<String, Box<dyn Error>> {
+    let circuit = GraphCircuit::from_run_args(&args, &model)?;
+    info!("Rendering circuit");
+
+    // Create the area we want to draw on.
+    // We could use SVGBackend if we want to render to .svg instead.
+    // for an overview of how to interpret these plots, see https://zcash.github.io/halo2/user/dev-tools.html
+    let root = BitMapBackend::new(&output, (512, 512)).into_drawing_area();
+    root.fill(&TRANSPARENT)?;
+    let root = root.titled("Layout", ("sans-serif", 20))?;
+
+    halo2_proofs::dev::CircuitLayout::default()
+        // We hide labels, else most circuits become impossible to decipher because of overlaid text
+        .show_labels(false)
+        .render(circuit.settings().run_args.logrows, &circuit, &root)?;
+    Ok(String::new())
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn create_evm_verifier(
     vk_path: PathBuf,
@@ -1383,10 +1400,10 @@ pub(crate) async fn deploy_evm(
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn verify_evm(
     proof_path: PathBuf,
-    addr_verifier: H160Flag,
+    addr_verifier: H160,
     rpc_url: Option<String>,
-    addr_da: Option<H160Flag>,
-    addr_vk: Option<H160Flag>,
+    addr_da: Option<H160>,
+    addr_vk: Option<H160>,
 ) -> Result<String, Box<dyn Error>> {
     use crate::eth::verify_proof_with_data_attestation;
     check_solc_requirement();
@@ -1396,20 +1413,14 @@ pub(crate) async fn verify_evm(
     let result = if let Some(addr_da) = addr_da {
         verify_proof_with_data_attestation(
             proof.clone(),
-            addr_verifier.into(),
-            addr_da.into(),
-            addr_vk.map(|s| s.into()),
+            addr_verifier,
+            addr_da,
+            addr_vk,
             rpc_url.as_deref(),
         )
         .await?
     } else {
-        verify_proof_via_solidity(
-            proof.clone(),
-            addr_verifier.into(),
-            addr_vk.map(|s| s.into()),
-            rpc_url.as_deref(),
-        )
-        .await?
+        verify_proof_via_solidity(proof.clone(), addr_verifier, addr_vk, rpc_url.as_deref()).await?
     };
 
     info!("Solidity verification result: {}", result);
@@ -1501,7 +1512,7 @@ pub(crate) fn setup(
     vk_path: PathBuf,
     pk_path: PathBuf,
     witness: Option<PathBuf>,
-    disable_selector_compression: bool,
+    compress_selectors: bool,
 ) -> Result<String, Box<dyn Error>> {
     // these aren't real values so the sanity checks are mostly meaningless
     let mut circuit = GraphCircuit::load(compiled_circuit)?;
@@ -1515,7 +1526,7 @@ pub(crate) fn setup(
     let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(
         &circuit,
         &params,
-        disable_selector_compression,
+        compress_selectors,
     )
     .map_err(Box::<dyn Error>::from)?;
 
@@ -1565,14 +1576,14 @@ pub(crate) async fn setup_test_evm_witness(
 use crate::pfsys::ProofType;
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn test_update_account_calls(
-    addr: H160Flag,
+    addr: H160,
     data: PathBuf,
     rpc_url: Option<String>,
 ) -> Result<String, Box<dyn Error>> {
     use crate::eth::update_account_calls;
 
     check_solc_requirement();
-    update_account_calls(addr.into(), data, rpc_url.as_deref()).await?;
+    update_account_calls(addr, data, rpc_url.as_deref()).await?;
 
     Ok(String::new())
 }
@@ -1656,7 +1667,7 @@ pub(crate) fn fuzz(
     data_path: PathBuf,
     transcript: TranscriptType,
     num_runs: usize,
-    disable_selector_compression: bool,
+    compress_selectors: bool,
 ) -> Result<String, Box<dyn Error>> {
     check_solc_requirement();
     let passed = AtomicBool::new(true);
@@ -1666,7 +1677,7 @@ pub(crate) fn fuzz(
     let logrows = circuit.settings().run_args.logrows;
 
     info!("setting up tests");
-    #[cfg(unix)]
+
     let _r = Gag::stdout()?;
     let params = gen_srs::<KZGCommitmentScheme<Bn256>>(logrows);
 
@@ -1675,7 +1686,7 @@ pub(crate) fn fuzz(
     let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(
         &circuit,
         &params,
-        disable_selector_compression,
+        compress_selectors,
     )
     .map_err(Box::<dyn Error>::from)?;
 
@@ -1684,7 +1695,6 @@ pub(crate) fn fuzz(
     let public_inputs = circuit.prepare_public_inputs(&data)?;
 
     let strategy = KZGSingleStrategy::new(&params);
-    #[cfg(unix)]
     std::mem::drop(_r);
 
     info!("starting fuzzing");
@@ -1697,7 +1707,7 @@ pub(crate) fn fuzz(
         let bad_pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(
             &circuit,
             &new_params,
-            disable_selector_compression,
+            compress_selectors,
         )
         .map_err(|_| ())?;
 
@@ -1718,7 +1728,6 @@ pub(crate) fn fuzz(
             bad_proof,
             pk.get_vk(),
             strategy.clone(),
-            params.n(),
         )
         .map_err(|_| ())
     };
@@ -1749,7 +1758,6 @@ pub(crate) fn fuzz(
             bad_proof,
             pk.get_vk(),
             strategy.clone(),
-            params.n(),
         )
         .map_err(|_| ())
     };
@@ -1775,7 +1783,7 @@ pub(crate) fn fuzz(
         let bad_pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(
             &circuit,
             &new_params,
-            disable_selector_compression,
+            compress_selectors,
         )
         .map_err(|_| ())?;
 
@@ -1786,7 +1794,6 @@ pub(crate) fn fuzz(
             proof.clone(),
             bad_vk,
             strategy.clone(),
-            params.n(),
         )
         .map_err(|_| ())
     };
@@ -1818,7 +1825,6 @@ pub(crate) fn fuzz(
             bad_proof,
             pk.get_vk(),
             strategy.clone(),
-            params.n(),
         )
         .map_err(|_| ())
     };
@@ -1854,7 +1860,6 @@ pub(crate) fn fuzz(
             bad_proof,
             pk.get_vk(),
             strategy.clone(),
-            params.n(),
         )
         .map_err(|_| ())
     };
@@ -1875,7 +1880,6 @@ pub(crate) fn run_fuzz_fn(
     passed: &AtomicBool,
 ) {
     let num_failures = AtomicI64::new(0);
-    #[cfg(unix)]
     let _r = Gag::stdout().unwrap();
 
     let pb = init_bar(num_runs as u64);
@@ -1889,7 +1893,6 @@ pub(crate) fn run_fuzz_fn(
         pb.inc(1);
     });
     pb.finish_with_message("Done.");
-    #[cfg(unix)]
     std::mem::drop(_r);
     info!(
         "num failures: {} out of {}",
@@ -1956,7 +1959,7 @@ pub(crate) fn setup_aggregate(
     srs_path: Option<PathBuf>,
     logrows: u32,
     split_proofs: bool,
-    disable_selector_compression: bool,
+    compress_selectors: bool,
 ) -> Result<String, Box<dyn Error>> {
     // the K used for the aggregation circuit
     let params = load_params_cmd(srs_path, logrows)?;
@@ -1970,7 +1973,7 @@ pub(crate) fn setup_aggregate(
     let agg_pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, AggregationCircuit>(
         &agg_circuit,
         &params,
-        disable_selector_compression,
+        compress_selectors,
     )?;
 
     let agg_vk = agg_pk.get_vk();
@@ -2042,30 +2045,15 @@ pub(crate) fn verify(
     settings_path: PathBuf,
     vk_path: PathBuf,
     srs_path: Option<PathBuf>,
-    reduced_srs: bool,
 ) -> Result<bool, Box<dyn Error>> {
     let circuit_settings = GraphSettings::load(&settings_path)?;
-
-    let params = if reduced_srs {
-        // only need G_0 for the verification with shplonk
-        load_params_cmd(srs_path, 1)?
-    } else {
-        load_params_cmd(srs_path, circuit_settings.run_args.logrows)?
-    };
-
+    let params = load_params_cmd(srs_path, circuit_settings.run_args.logrows)?;
     let proof = Snark::load::<KZGCommitmentScheme<Bn256>>(&proof_path)?;
 
     let strategy = KZGSingleStrategy::new(params.verifier_params());
-    let vk =
-        load_vk::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(vk_path, circuit_settings.clone())?;
+    let vk = load_vk::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(vk_path, circuit_settings)?;
     let now = Instant::now();
-    let result = verify_proof_circuit_kzg(
-        params.verifier_params(),
-        proof,
-        &vk,
-        strategy,
-        1 << circuit_settings.run_args.logrows,
-    );
+    let result = verify_proof_circuit_kzg(params.verifier_params(), proof, &vk, strategy);
     let elapsed = now.elapsed();
     info!(
         "verify took {}.{}",
@@ -2089,7 +2077,7 @@ pub(crate) fn verify_aggr(
     let strategy = AccumulatorStrategy::new(params.verifier_params());
     let vk = load_vk::<KZGCommitmentScheme<Bn256>, Fr, AggregationCircuit>(vk_path, ())?;
     let now = Instant::now();
-    let result = verify_proof_circuit_kzg(&params, proof, &vk, strategy, 1 << logrows);
+    let result = verify_proof_circuit_kzg(&params, proof, &vk, strategy);
 
     let elapsed = now.elapsed();
     info!(

src/graph/input.rs

@@ -4,7 +4,6 @@ use crate::circuit::InputType;
 use crate::fieldutils::i128_to_felt;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::tensor::Tensor;
-use crate::EZKL_BUF_CAPACITY;
 use halo2curves::bn256::Fr as Fp;
 #[cfg(not(target_arch = "wasm32"))]
 use postgres::{Client, NoTls};
@@ -16,8 +15,6 @@ use pyo3::types::PyDict;
 use pyo3::ToPyObject;
 use serde::ser::SerializeStruct;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use std::io::BufReader;
-use std::io::BufWriter;
 use std::io::Read;
 use std::panic::UnwindSafe;
 #[cfg(not(target_arch = "wasm32"))]
@@ -493,20 +490,16 @@ impl GraphData {
 
     /// Load the model input from a file
     pub fn from_path(path: std::path::PathBuf) -> Result<Self, Box<dyn std::error::Error>> {
-        let reader = std::fs::File::open(path)?;
-        let mut reader = BufReader::with_capacity(*EZKL_BUF_CAPACITY, reader);
-        let mut buf = String::new();
-        reader.read_to_string(&mut buf)?;
-        let graph_input = serde_json::from_str(&buf)?;
-        Ok(graph_input)
+        let mut file = std::fs::File::open(path.clone())
+            .map_err(|_| format!("failed to open input at {}", path.display()))?;
+        let mut data = String::new();
+        file.read_to_string(&mut data)?;
+        serde_json::from_str(&data).map_err(|e| e.into())
     }
 
     /// Save the model input to a file
     pub fn save(&self, path: std::path::PathBuf) -> Result<(), Box<dyn std::error::Error>> {
-        // buf writer
-        let writer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, std::fs::File::create(path)?);
-        serde_json::to_writer(writer, self)?;
-        Ok(())
+        serde_json::to_writer(std::fs::File::create(path)?, &self).map_err(|e| e.into())
     }
 
     ///
@@ -624,13 +617,13 @@ impl ToPyObject for DataSource {
 }
 
 #[cfg(feature = "python-bindings")]
-use crate::pfsys::field_to_string;
+use crate::pfsys::field_to_string_montgomery;
 
 #[cfg(feature = "python-bindings")]
 impl ToPyObject for FileSourceInner {
     fn to_object(&self, py: Python) -> PyObject {
         match self {
-            FileSourceInner::Field(data) => field_to_string(data).to_object(py),
+            FileSourceInner::Field(data) => field_to_string_montgomery(data).to_object(py),
             FileSourceInner::Bool(data) => data.to_object(py),
             FileSourceInner::Float(data) => data.to_object(py),
         }