ci: update version string in docs

.github/workflows/engine.yml

@@ -22,15 +22,18 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: jetli/wasm-pack-action@v0.4.0
+        with:
+          # Pin to version 0.12.1
+          version: 'v0.12.1'
       - name: Add wasm32-unknown-unknown target
         run: rustup target add wasm32-unknown-unknown
 
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
       - name: Install binaryen
         run: |
           set -e

.github/workflows/large-tests.yml

@@ -11,7 +11,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - name: nanoGPT Mock

.github/workflows/pypi.yml

@@ -40,7 +40,7 @@ jobs:
 
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
 
@@ -86,7 +86,7 @@ jobs:
 
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
 

.github/workflows/release.yml

@@ -45,7 +45,7 @@ jobs:
     steps:
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - name: Checkout repo
@@ -106,27 +106,27 @@ jobs:
         include:
           - build: windows-msvc
             os: windows-latest
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
             target: x86_64-pc-windows-msvc
           - build: macos
             os: macos-13
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
             target: x86_64-apple-darwin
           - build: macos-aarch64
             os: macos-13
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
             target: aarch64-apple-darwin
           - build: linux-musl
             os: ubuntu-22.04
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
             target: x86_64-unknown-linux-musl
           - build: linux-gnu
             os: ubuntu-22.04
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
             target: x86_64-unknown-linux-gnu
           - build: linux-aarch64
             os: ubuntu-22.04
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
             target: aarch64-unknown-linux-gnu
 
     steps:
@@ -181,9 +181,14 @@ jobs:
           echo "target flag is: ${{ env.TARGET_FLAGS }}"
           echo "target dir is: ${{ env.TARGET_DIR }}"
 
-      - name: Build release binary
+      - name: Build release binary (no asm)
+        if: matrix.build != 'linux-gnu'
         run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry
 
+      - name: Build release binary (asm)
+        if: matrix.build == 'linux-gnu'
+        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry --features asm
+
       - name: Strip release binary
         if: matrix.build != 'windows-msvc' && matrix.build != 'linux-aarch64'
         run: strip "target/${{ matrix.target }}/release/ezkl"

.github/workflows/rust.yml

@@ -26,7 +26,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           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-02-06
+          toolchain: nightly-2024-07-18
           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-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -65,40 +65,40 @@ jobs:
       - name: Library tests (original lookup)
         run: cargo nextest run --lib --verbose --no-default-features --features ezkl
 
-  ultra-overflow-tests-gpu:
-    runs-on: GPU
-    env:
-      ENABLE_ICICLE_GPU: true
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly-2024-02-06
-          override: true
-          components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@v1
-        with:
-          crate: cargo-nextest
-          locked: true
-      - uses: mwilliamson/setup-wasmtime-action@v2
-        with:
-          wasmtime-version: "3.0.1"
-      - name: Install wasm32-wasi
-        run: rustup target add wasm32-wasi
-      - name: Install cargo-wasi
-        run: cargo install cargo-wasi
-      # - name: Matmul overflow (wasi)
-      #   run: cargo wasi test matmul_col_ultra_overflow -- --include-ignored --nocapture
-      # - name: Conv overflow (wasi)
-      #   run: cargo wasi test conv_col_ultra_overflow -- --include-ignored --nocapture
-      - name: lookup overflow
-        run: cargo nextest run  --release lookup_ultra_overflow --no-capture --features icicle -- --include-ignored
-      - name: Matmul overflow
-        run: RUST_LOG=debug cargo nextest run matmul_col_ultra_overflow --no-capture --features icicle -- --include-ignored
-      - name: Conv overflow
-        run: RUST_LOG=debug cargo nextest run conv_col_ultra_overflow --no-capture --features icicle -- --include-ignored
-      - name: Conv + relu overflow
-        run: cargo nextest run  --release conv_relu_col_ultra_overflow --no-capture --features icicle -- --include-ignored
+  # ultra-overflow-tests-gpu:
+  #   runs-on: GPU
+  #   env:
+  #     ENABLE_ICICLE_GPU: true
+  #   steps:
+  #     - uses: actions/checkout@v4
+  #     - uses: actions-rs/toolchain@v1
+  #       with:
+  #         toolchain: nightly-2024-07-18
+  #         override: true
+  #         components: rustfmt, clippy
+  #     - uses: baptiste0928/cargo-install@v1
+  #       with:
+  #         crate: cargo-nextest
+  #         locked: true
+  #     - uses: mwilliamson/setup-wasmtime-action@v2
+  #       with:
+  #         wasmtime-version: "3.0.1"
+  #     - name: Install wasm32-wasi
+  #       run: rustup target add wasm32-wasi
+  #     - name: Install cargo-wasi
+  #       run: cargo install cargo-wasi
+  #     # - name: Matmul overflow (wasi)
+  #     #   run: cargo wasi test matmul_col_ultra_overflow -- --include-ignored --nocapture
+  #     # - name: Conv overflow (wasi)
+  #     #   run: cargo wasi test conv_col_ultra_overflow -- --include-ignored --nocapture
+  #     - name: lookup overflow
+  #       run: cargo nextest run lookup_ultra_overflow --no-capture --features icicle -- --include-ignored
+  #     - name: Matmul overflow
+  #       run: RUST_LOG=debug cargo nextest run matmul_col_ultra_overflow --no-capture --features icicle -- --include-ignored
+  #     - name: Conv overflow
+  #       run: RUST_LOG=debug cargo nextest run conv_col_ultra_overflow --no-capture --features icicle -- --include-ignored
+  #     - name: Conv + relu overflow
+  #       run: cargo nextest run conv_relu_col_ultra_overflow --no-capture --features icicle -- --include-ignored
 
   ultra-overflow-tests_og-lookup:
     runs-on: non-gpu
@@ -106,7 +106,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           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-02-06
+          toolchain: nightly-2024-07-18
           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-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -184,22 +184,24 @@ jobs:
 
   wasm32-tests:
     runs-on: ubuntu-latest
-    needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: jetli/wasm-pack-action@v0.4.0
+        with:
+          # Pin to version 0.12.1
+          version: 'v0.12.1'
       - uses: nanasess/setup-chromedriver@v2
         # with:
         #   chromedriver-version: "115.0.5790.102"
       - name: Install wasm32-unknown-unknown
         run: rustup target add wasm32-unknown-unknown
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-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-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -229,17 +231,19 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
+      # - name: The Worm Mock
+      #   run: cargo nextest run --release --verbose tests::large_mock_::large_tests_5_expects -- --include-ignored
       - 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
+        run: cargo nextest run --release --verbose tests::mock_large_batch_public_outputs_ --test-threads 16
       - name: kzg inputs
         run: cargo nextest run --release --verbose tests::mock_kzg_input_::t  --test-threads 32
       - name: kzg params
@@ -258,6 +262,8 @@ jobs:
         run: cargo nextest run --release --verbose tests::mock_hashed_input_::t  --test-threads 32
       - name: hashed params
         run: cargo nextest run --release --verbose tests::mock_hashed_params_::t  --test-threads 32
+      - name: hashed params public inputs
+        run: cargo nextest run --release --verbose tests::mock_hashed_params_public_inputs_::t  --test-threads 32
       - name: hashed outputs
         run: cargo nextest run --release --verbose tests::mock_hashed_output_::t  --test-threads 32
       - name: hashed inputs + params + outputs
@@ -286,7 +292,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -304,7 +310,7 @@ jobs:
           node-version: "18.12.1"
           cache: "pnpm"
       - name: "Add rust-src"
-        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
       - name: Install dependencies for js tests and in-browser-evm-verifier package
         run: |
           pnpm install --frozen-lockfile
@@ -323,12 +329,12 @@ jobs:
           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 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 c2233ec9fe61e0920c61c6d779bc707252852037 --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
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
+      - name: KZG prove and verify tests (EVM + reusable verifier + col-overflow)
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_prove_and_verify_reusable_verifier --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg all)
         run: cargo nextest run --release --verbose tests_evm::kzg_evm_kzg_all_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg inputs)
@@ -365,15 +371,18 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: jetli/wasm-pack-action@v0.4.0
+        with:
+          # Pin to version 0.12.1
+          version: 'v0.12.1'
       - name: Add wasm32-unknown-unknown target
         run: rustup target add wasm32-unknown-unknown
 
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
       - uses: actions/checkout@v3
       - name: Use pnpm 8
         uses: pnpm/action-setup@v2
@@ -431,40 +440,40 @@ jobs:
       - name: KZG prove and verify tests (hashed outputs)
         run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed
 
-  prove-and-verify-tests-gpu:
-    runs-on: GPU
-    env:
-      ENABLE_ICICLE_GPU: true
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly-2024-02-06
-          override: true
-          components: rustfmt, clippy
-      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
-      - uses: actions/checkout@v3
-      - uses: baptiste0928/cargo-install@v1
-        with:
-          crate: cargo-nextest
-          locked: true
-      - name: KZG prove and verify tests (kzg outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output --features icicle --test-threads 1
-      - name: KZG prove and verify tests (public outputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w --features icicle  --test-threads 1
-      - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_ --features icicle  --test-threads 1
-      - name: KZG prove and verify tests (public outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
-      - name: KZG prove and verify tests (public outputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
-      - name: KZG prove and verify tests (public inputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input --features icicle  --test-threads 1
-      - name: KZG prove and verify tests (fixed params)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params --features icicle  --test-threads 1
-      - name: KZG prove and verify tests (hashed outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1
+  # prove-and-verify-tests-gpu:
+  #   runs-on: GPU
+  #   env:
+  #     ENABLE_ICICLE_GPU: true
+  #   steps:
+  #     - uses: actions/checkout@v4
+  #     - uses: actions-rs/toolchain@v1
+  #       with:
+  #         toolchain: nightly-2024-07-18
+  #         override: true
+  #         components: rustfmt, clippy
+  #     - name: Add rust-src
+  #       run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
+  #     - uses: actions/checkout@v3
+  #     - uses: baptiste0928/cargo-install@v1
+  #       with:
+  #         crate: cargo-nextest
+  #         locked: true
+  #     - name: KZG prove and verify tests (kzg outputs)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output --features icicle --test-threads 1
+  #     - name: KZG prove and verify tests (public outputs + column overflow)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w --features icicle  --test-threads 1
+  #     - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_ --features icicle  --test-threads 1
+  #     - name: KZG prove and verify tests (public outputs)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
+  #     - name: KZG prove and verify tests (public outputs + column overflow)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
+  #     - name: KZG prove and verify tests (public inputs)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input --features icicle  --test-threads 1
+  #     - name: KZG prove and verify tests (fixed params)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params --features icicle  --test-threads 1
+  #     - name: KZG prove and verify tests (hashed outputs)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1
 
   prove-and-verify-mock-aggr-tests:
     runs-on: self-hosted
@@ -473,7 +482,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -491,7 +500,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -499,7 +508,7 @@ jobs:
           crate: cargo-nextest
           locked: true
       - name: KZG )tests
-        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --features icicle --test-threads 1 -- --include-ignored
+        run: cargo nextest run --verbose tests_aggr::kzg_aggr_prove_and_verify_  --features icicle --test-threads 1 -- --include-ignored
 
   prove-and-verify-aggr-tests:
     runs-on: large-self-hosted
@@ -508,7 +517,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -525,17 +534,17 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
-      - name: Install solc
-        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
+      # - 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 c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --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
 
@@ -546,7 +555,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -566,17 +575,17 @@ jobs:
           python-version: "3.12"
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - name: Install cmake
         run: sudo apt-get install -y cmake
-      - name: Install solc
-        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
+      # - name: Install solc
+      #   run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
       - name: Setup Virtual Env and Install python dependencies
         run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt;
       - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
       - name: Build python ezkl
         run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
       - name: Run pytest
@@ -592,7 +601,7 @@ jobs:
           python-version: "3.12"
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -641,17 +650,17 @@ jobs:
           python-version: "3.11"
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
-      - name: Install solc
-        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
+      # - 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 c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
       - name: Install pip
         run: python -m ensurepip --upgrade
       - name: Setup Virtual Env and Install python dependencies
@@ -677,3 +686,5 @@ jobs:
         run: source .env/bin/activate; cargo nextest run py_tests::tests::voice_
       - name: NBEATS tutorial
         run: source .env/bin/activate; cargo nextest run py_tests::tests::nbeats_
+      # - name: Reusable verifier tutorial
+        # run: source .env/bin/activate; cargo nextest run py_tests::tests::reusable_

Cargo.toml

@@ -16,19 +16,19 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch = "ac/optional-selector-poly" }
-halo2_proofs = { git = "https://github.com/zkonduit/halo2", branch = "ac/optional-selector-poly" }
-halo2curves = { git = "https://github.com/privacy-scaling-explorations/halo2curves", rev = "9fff22c", features = [
+halo2curves = { git = "https://github.com/privacy-scaling-explorations/halo2curves", rev = "b753a832e92d5c86c5c997327a9cf9de86a18851", features = [
     "derive_serde",
 ] }
+halo2_proofs = { git = "https://github.com/zkonduit/halo2?branch=ac/cache-lookup-commitments#8b13a0d2a7a34d8daab010dadb2c47dfa47d37d0", package = "halo2_proofs", branch = "ac/cache-lookup-commitments" }
 rand = { version = "0.8", default_features = false }
 itertools = { version = "0.10.3", default_features = false }
 clap = { version = "4.5.3", features = ["derive"] }
-clap_complete = "4.5.2"
 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 }
+clap_complete = "4.5.2"
 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 }
@@ -36,21 +36,26 @@ halo2_wrong_ecc = { git = "https://github.com/zkonduit/halo2wrong", branch = "ac
 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" }
+halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier", branch = "ac/update-h2-curves" }
 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" }
-metal = { git = "https://github.com/gfx-rs/metal-rs", optional = true }
 semver = "1.0.22"
 
 # evm related deps
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-alloy = { git = "https://github.com/alloy-rs/alloy", version = "0.1.0", rev="5fbf57bac99edef9d8475190109a7ea9fb7e5e83", features = ["provider-http", "signers", "contract", "rpc-types-eth", "signer-wallet", "node-bindings"] }
-foundry-compilers = {version = "0.4.1", features = ["svm-solc"]}
+alloy = { git = "https://github.com/alloy-rs/alloy", version = "0.1.0", rev = "5fbf57bac99edef9d8475190109a7ea9fb7e5e83", features = [
+    "provider-http",
+    "signers",
+    "contract",
+    "rpc-types-eth",
+    "signer-wallet",
+    "node-bindings",
+] }
+foundry-compilers = { version = "0.4.1", features = ["svm-solc"] }
 ethabi = "18"
 indicatif = { version = "0.17.5", features = ["rayon"] }
 gag = { version = "1.0.0", default_features = false }
@@ -63,31 +68,29 @@ reqwest = { version = "0.12.4", default-features = false, features = [
 openssl = { version = "0.10.55", features = ["vendored"] }
 tokio-postgres = "0.7.10"
 pg_bigdecimal = "0.1.5"
-futures-util = "0.3.30"
 lazy_static = "1.4.0"
 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.35", default_features = false, features = [
+tokio = { version = "1.35.0", default_features = false, features = [
     "macros",
-    "rt-multi-thread"
+    "rt-multi-thread",
 ] }
-tokio-util = { version = "0.7.9", features = ["codec"] }
 pyo3 = { version = "0.21.2", features = [
     "extension-module",
     "abi3-py37",
     "macros",
 ], default_features = false, optional = true }
-pyo3-asyncio = { git = "https://github.com/jopemachine/pyo3-asyncio/", branch="migration-pyo3-0.21", features = [
+pyo3-asyncio = { git = "https://github.com/jopemachine/pyo3-asyncio/", branch = "migration-pyo3-0.21", features = [
     "attributes",
     "tokio-runtime",
 ], default_features = false, optional = true }
+
 pyo3-log = { version = "0.10.0", default_features = false, optional = true }
-tract-onnx = { git = "https://github.com/sonos/tract/", rev = "05ebf550aa9922b221af4635c21a67a8d2af12a9", default_features = false, optional = true }
+tract-onnx = { git = "https://github.com/sonos/tract/", rev = "40c64319291184814d9fea5fdf4fa16f5a4f7116", default_features = false, optional = true }
 tabled = { version = "0.12.0", optional = true }
-
+metal = { git = "https://github.com/gfx-rs/metal-rs", optional = true }
 objc = { version = "0.2.4", optional = true }
-
+mimalloc = "0.1"
 
 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
 colored = { version = "2.0.0", default_features = false, optional = true }
@@ -95,6 +98,7 @@ 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"] }
@@ -108,8 +112,10 @@ console_error_panic_hook = "0.1.7"
 wasm-bindgen-console-logger = "0.1.1"
 
 
+[target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dev-dependencies]
+criterion = { version = "0.5.1", features = ["html_reports"] }
+
 [dev-dependencies]
-criterion = { version = "0.3", features = ["html_reports"] }
 tempfile = "3.3.0"
 lazy_static = "1.4.0"
 mnist = "0.5"
@@ -163,6 +169,10 @@ harness = false
 name = "relu"
 harness = false
 
+[[bench]]
+name = "relu_lookupless"
+harness = false
+
 [[bench]]
 name = "accum_matmul_relu"
 harness = false
@@ -180,7 +190,13 @@ required-features = ["ezkl"]
 
 [features]
 web = ["wasm-bindgen-rayon"]
-default = ["ezkl", "mv-lookup", "no-banner"]
+default = [
+    "ezkl",
+    "mv-lookup",
+    "precompute-coset",
+    "no-banner",
+    "parallel-poly-read",
+]
 onnx = ["dep:tract-onnx"]
 python-bindings = ["pyo3", "pyo3-log", "pyo3-asyncio"]
 ezkl = [
@@ -194,25 +210,30 @@ ezkl = [
     "colored_json",
     "halo2_proofs/circuit-params",
 ]
+parallel-poly-read = ["halo2_proofs/parallel-poly-read"]
 mv-lookup = [
     "halo2_proofs/mv-lookup",
     "snark-verifier/mv-lookup",
     "halo2_solidity_verifier/mv-lookup",
 ]
+asm = ["halo2curves/asm", "halo2_proofs/asm"]
+precompute-coset = ["halo2_proofs/precompute-coset"]
 det-prove = []
 icicle = ["halo2_proofs/icicle_gpu"]
 empty-cmd = []
 no-banner = []
 no-update = []
-metal = ["dep:metal", "dep:objc"]
+
 
 # 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" }
 
 [patch.'https://github.com/zkonduit/halo2']
-halo2_proofs = { git = "https://github.com/zkonduit/halo2?branch=ac/optional-selector-poly#54f54453cf186aa5d89579c4e7663f9a27cfb89a", package = "halo2_proofs", branch = "ac/optional-selector-poly" }
-
+halo2_proofs = { git = "https://github.com/zkonduit/halo2?branch=ac/cache-lookup-commitments#8b13a0d2a7a34d8daab010dadb2c47dfa47d37d0", package = "halo2_proofs", branch = "ac/cache-lookup-commitments" }
 
 [profile.release]
 rustflags = ["-C", "relocation-model=pic"]
+lto = "fat"
+codegen-units = 1
+# panic = "abort"

benches/accum_conv.rs

@@ -64,7 +64,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(
                         &mut region,
@@ -72,6 +72,7 @@ impl Circuit<Fr> for MyCircuit {
                         Box::new(PolyOp::Conv {
                             padding: vec![(0, 0)],
                             stride: vec![1; 2],
+                            group: 1,
                         }),
                     )
                     .unwrap();

benches/accum_dot.rs

@@ -55,7 +55,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(
                         &mut region,

benches/accum_einsum_matmul.rs

@@ -57,7 +57,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(
                         &mut region,

benches/accum_matmul_relu.rs

@@ -57,7 +57,15 @@ impl Circuit<Fr> for MyCircuit {
 
         // sets up a new relu table
         base_config
-            .configure_lookup(cs, &b, &output, &a, BITS, K, &LookupOp::ReLU)
+            .configure_lookup(
+                cs,
+                &b,
+                &output,
+                &a,
+                BITS,
+                K,
+                &LookupOp::LeakyReLU { slope: 0.0.into() },
+            )
             .unwrap();
 
         MyConfig { base_config }
@@ -75,14 +83,18 @@ impl Circuit<Fr> for MyCircuit {
                 let op = PolyOp::Einsum {
                     equation: "ij,jk->ik".to_string(),
                 };
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 let output = config
                     .base_config
                     .layout(&mut region, &self.inputs, Box::new(op))
                     .unwrap();
                 let _output = config
                     .base_config
-                    .layout(&mut region, &[output.unwrap()], Box::new(LookupOp::ReLU))
+                    .layout(
+                        &mut region,
+                        &[output.unwrap()],
+                        Box::new(LookupOp::LeakyReLU { slope: 0.0.into() }),
+                    )
                     .unwrap();
                 Ok(())
             },

benches/accum_matmul_relu_overflow.rs

@@ -58,7 +58,15 @@ impl Circuit<Fr> for MyCircuit {
 
         // sets up a new relu table
         base_config
-            .configure_lookup(cs, &b, &output, &a, BITS, k, &LookupOp::ReLU)
+            .configure_lookup(
+                cs,
+                &b,
+                &output,
+                &a,
+                BITS,
+                k,
+                &LookupOp::LeakyReLU { slope: 0.0.into() },
+            )
             .unwrap();
 
         MyConfig { base_config }
@@ -76,14 +84,18 @@ impl Circuit<Fr> for MyCircuit {
                 let op = PolyOp::Einsum {
                     equation: "ij,jk->ik".to_string(),
                 };
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 let output = config
                     .base_config
                     .layout(&mut region, &self.inputs, Box::new(op))
                     .unwrap();
                 let _output = config
                     .base_config
-                    .layout(&mut region, &[output.unwrap()], Box::new(LookupOp::ReLU))
+                    .layout(
+                        &mut region,
+                        &[output.unwrap()],
+                        Box::new(LookupOp::LeakyReLU { slope: 0.0.into() }),
+                    )
                     .unwrap();
                 Ok(())
             },

benches/accum_sum.rs

@@ -55,7 +55,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(
                         &mut region,

benches/accum_sumpool.rs

@@ -59,7 +59,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(
                         &mut region,

benches/pairwise_add.rs

@@ -55,7 +55,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(&mut region, &self.inputs, Box::new(PolyOp::Add))
                     .unwrap();

benches/pairwise_pow.rs

@@ -56,7 +56,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = RegionCtx::new(region, 0, 1);
+                let mut region = RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(&mut region, &self.inputs, Box::new(PolyOp::Pow(4)))
                     .unwrap();

benches/relu.rs

@@ -2,6 +2,7 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::table::Range;
 use ezkl::circuit::{ops::lookup::LookupOp, BaseConfig as Config, CheckMode};
+use ezkl::fieldutils::IntegerRep;
 use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
@@ -41,7 +42,7 @@ impl Circuit<Fr> for NLCircuit {
                 .map(|_| VarTensor::new_advice(cs, K, 1, LEN))
                 .collect::<Vec<_>>();
 
-            let nl = LookupOp::ReLU;
+            let nl = LookupOp::LeakyReLU { slope: 0.0.into() };
 
             let mut config = Config::default();
 
@@ -62,9 +63,13 @@ impl Circuit<Fr> for NLCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = RegionCtx::new(region, 0, 1);
+                let mut region = RegionCtx::new(region, 0, 1, 1024, 2);
                 config
-                    .layout(&mut region, &[self.input.clone()], Box::new(LookupOp::ReLU))
+                    .layout(
+                        &mut region,
+                        &[self.input.clone()],
+                        Box::new(LookupOp::LeakyReLU { slope: 0.0.into() }),
+                    )
                     .unwrap();
                 Ok(())
             },
@@ -84,7 +89,7 @@ fn runrelu(c: &mut Criterion) {
         };
 
         let input: Tensor<Value<Fr>> =
-            Tensor::<i32>::from((0..len).map(|_| rng.gen_range(0..10))).into();
+            Tensor::<IntegerRep>::from((0..len).map(|_| rng.gen_range(0..10))).into();
 
         let circuit = NLCircuit {
             input: ValTensor::from(input.clone()),

benches/relu_lookupless.rs

@@ -0,0 +1,143 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use ezkl::circuit::poly::PolyOp;
+use ezkl::circuit::region::RegionCtx;
+use ezkl::circuit::{BaseConfig as Config, CheckMode};
+use ezkl::fieldutils::IntegerRep;
+use ezkl::pfsys::create_proof_circuit;
+use ezkl::pfsys::TranscriptType;
+use ezkl::pfsys::{create_keys, srs::gen_srs};
+use ezkl::tensor::*;
+use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
+use halo2_proofs::poly::kzg::strategy::SingleStrategy;
+use halo2_proofs::{
+    circuit::{Layouter, SimpleFloorPlanner, Value},
+    plonk::{Circuit, ConstraintSystem, Error},
+};
+use halo2curves::bn256::{Bn256, Fr};
+use rand::Rng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
+
+static mut LEN: usize = 4;
+const K: usize = 16;
+
+#[derive(Clone)]
+struct NLCircuit {
+    pub input: ValTensor<Fr>,
+}
+
+impl Circuit<Fr> for NLCircuit {
+    type Config = Config<Fr>;
+    type FloorPlanner = SimpleFloorPlanner;
+    type Params = ();
+
+    fn without_witnesses(&self) -> Self {
+        self.clone()
+    }
+
+    fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
+        unsafe {
+            let advices = (0..3)
+                .map(|_| VarTensor::new_advice(cs, K, 1, LEN))
+                .collect::<Vec<_>>();
+
+            let mut config = Config::default();
+
+            config
+                .configure_range_check(cs, &advices[0], &advices[1], (-1, 1), K)
+                .unwrap();
+
+            config
+                .configure_range_check(cs, &advices[0], &advices[1], (0, 1023), K)
+                .unwrap();
+
+            let _constant = VarTensor::constant_cols(cs, K, LEN, false);
+
+            config
+        }
+    }
+
+    fn synthesize(
+        &self,
+        mut config: Self::Config,
+        mut layouter: impl Layouter<Fr>, // layouter is our 'write buffer' for the circuit
+    ) -> Result<(), Error> {
+        config.layout_range_checks(&mut layouter).unwrap();
+        layouter.assign_region(
+            || "",
+            |region| {
+                let mut region = RegionCtx::new(region, 0, 1, 1024, 2);
+                config
+                    .layout(&mut region, &[self.input.clone()], Box::new(PolyOp::ReLU))
+                    .unwrap();
+                Ok(())
+            },
+        )?;
+        Ok(())
+    }
+}
+
+fn runrelu(c: &mut Criterion) {
+    let mut group = c.benchmark_group("relu");
+
+    let mut rng = rand::thread_rng();
+    let params = gen_srs::<KZGCommitmentScheme<_>>(17);
+    for &len in [4, 8].iter() {
+        unsafe {
+            LEN = len;
+        };
+
+        let input: Tensor<Value<Fr>> =
+            Tensor::<IntegerRep>::from((0..len).map(|_| rng.gen_range(0..10))).into();
+
+        let circuit = NLCircuit {
+            input: ValTensor::from(input.clone()),
+        };
+
+        group.throughput(Throughput::Elements(len as u64));
+        group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
+            b.iter(|| {
+                create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, &params, true)
+                    .unwrap();
+            });
+        });
+
+        let pk =
+            create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, &params, true).unwrap();
+
+        group.throughput(Throughput::Elements(len as u64));
+        group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
+            b.iter(|| {
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    NLCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
+                    circuit.clone(),
+                    vec![],
+                    &params,
+                    &pk,
+                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
+                    TranscriptType::EVM,
+                    None,
+                    None,
+                );
+                prover.unwrap();
+            });
+        });
+    }
+    group.finish();
+}
+
+criterion_group! {
+  name = benches;
+  config = Criterion::default().with_plots();
+  targets = runrelu
+}
+criterion_main!(benches);

docs/python/requirements-docs.txt

@@ -1,4 +1,4 @@
-ezkl==11.4.3
+ezkl==14.1.0
 sphinx
 sphinx-rtd-theme
 sphinxcontrib-napoleon

docs/python/src/conf.py

@@ -1,7 +1,7 @@
 import ezkl
 
 project = 'ezkl'
-release = '11.4.3'
+release = '14.1.0'
 version = release
 
 

examples/conv2d_mnist/main.rs

@@ -2,8 +2,7 @@ use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::{
     ops::lookup::LookupOp, ops::poly::PolyOp, BaseConfig as PolyConfig, CheckMode,
 };
-use ezkl::fieldutils;
-use ezkl::fieldutils::i32_to_felt;
+use ezkl::fieldutils::{self, integer_rep_to_felt, IntegerRep};
 use ezkl::tensor::*;
 use halo2_proofs::dev::MockProver;
 use halo2_proofs::poly::commitment::Params;
@@ -42,8 +41,8 @@ const NUM_INNER_COLS: usize = 1;
 struct Config<
     const LEN: usize, //LEN = CHOUT x OH x OW flattened //not supported yet in rust stable
     const CLASSES: usize,
-    const LOOKUP_MIN: i64,
-    const LOOKUP_MAX: i64,
+    const LOOKUP_MIN: IntegerRep,
+    const LOOKUP_MAX: IntegerRep,
     // Convolution
     const KERNEL_HEIGHT: usize,
     const KERNEL_WIDTH: usize,
@@ -66,8 +65,8 @@ struct Config<
 struct MyCircuit<
     const LEN: usize, //LEN = CHOUT x OH x OW flattened
     const CLASSES: usize,
-    const LOOKUP_MIN: i64,
-    const LOOKUP_MAX: i64,
+    const LOOKUP_MIN: IntegerRep,
+    const LOOKUP_MAX: IntegerRep,
     // Convolution
     const KERNEL_HEIGHT: usize,
     const KERNEL_WIDTH: usize,
@@ -90,8 +89,8 @@ struct MyCircuit<
 impl<
         const LEN: usize,
         const CLASSES: usize,
-        const LOOKUP_MIN: i64,
-        const LOOKUP_MAX: i64,
+        const LOOKUP_MIN: IntegerRep,
+        const LOOKUP_MAX: IntegerRep,
         // Convolution
         const KERNEL_HEIGHT: usize,
         const KERNEL_WIDTH: usize,
@@ -164,7 +163,7 @@ where
                 &params,
                 (LOOKUP_MIN, LOOKUP_MAX),
                 K,
-                &LookupOp::ReLU,
+                &LookupOp::LeakyReLU { slope: 0.0.into() },
             )
             .unwrap();
 
@@ -200,11 +199,12 @@ where
             .assign_region(
                 || "mlp_4d",
                 |region| {
-                    let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS);
+                    let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS, 1024, 2);
 
                     let op = PolyOp::Conv {
                         padding: vec![(PADDING, PADDING); 2],
                         stride: vec![STRIDE; 2],
+                        group: 1,
                     };
                     let x = config
                         .layer_config
@@ -221,7 +221,11 @@ where
 
                     let x = config
                         .layer_config
-                        .layout(&mut region, &[x.unwrap()], Box::new(LookupOp::ReLU))
+                        .layout(
+                            &mut region,
+                            &[x.unwrap()],
+                            Box::new(LookupOp::LeakyReLU { slope: 0.0.into() }),
+                        )
                         .unwrap();
 
                     let mut x = config
@@ -315,7 +319,11 @@ pub fn runconv() {
         .test_set_length(10_000)
         .finalize();
 
-    let mut train_data = Tensor::from(trn_img.iter().map(|x| i32_to_felt::<F>(*x as i32 / 16)));
+    let mut train_data = Tensor::from(
+        trn_img
+            .iter()
+            .map(|x| integer_rep_to_felt::<F>(*x as IntegerRep / 16)),
+    );
     train_data.reshape(&[50_000, 28, 28]).unwrap();
 
     let mut train_labels = Tensor::from(trn_lbl.iter().map(|x| *x as f32));
@@ -343,8 +351,8 @@ pub fn runconv() {
             .map(|fl| {
                 let dx = fl * 32_f32;
                 let rounded = dx.round();
-                let integral: i32 = unsafe { rounded.to_int_unchecked() };
-                fieldutils::i32_to_felt(integral)
+                let integral: IntegerRep = unsafe { rounded.to_int_unchecked() };
+                fieldutils::integer_rep_to_felt(integral)
             }),
     );
 
@@ -355,7 +363,8 @@ pub fn runconv() {
 
     let l0_kernels = l0_kernels.try_into().unwrap();
 
-    let mut l0_bias = Tensor::<F>::from((0..OUT_CHANNELS).map(|_| fieldutils::i32_to_felt(0)));
+    let mut l0_bias =
+        Tensor::<F>::from((0..OUT_CHANNELS).map(|_| fieldutils::integer_rep_to_felt(0)));
     l0_bias.set_visibility(&ezkl::graph::Visibility::Private);
 
     let l0_bias = l0_bias.try_into().unwrap();
@@ -363,8 +372,8 @@ pub fn runconv() {
     let mut l2_biases = Tensor::<F>::from(myparams.biases.into_iter().map(|fl| {
         let dx = fl * 32_f32;
         let rounded = dx.round();
-        let integral: i32 = unsafe { rounded.to_int_unchecked() };
-        fieldutils::i32_to_felt(integral)
+        let integral: IntegerRep = unsafe { rounded.to_int_unchecked() };
+        fieldutils::integer_rep_to_felt(integral)
     }));
     l2_biases.set_visibility(&ezkl::graph::Visibility::Private);
     l2_biases.reshape(&[l2_biases.len(), 1]).unwrap();
@@ -374,8 +383,8 @@ pub fn runconv() {
     let mut l2_weights = Tensor::<F>::from(myparams.weights.into_iter().flatten().map(|fl| {
         let dx = fl * 32_f32;
         let rounded = dx.round();
-        let integral: i32 = unsafe { rounded.to_int_unchecked() };
-        fieldutils::i32_to_felt(integral)
+        let integral: IntegerRep = unsafe { rounded.to_int_unchecked() };
+        fieldutils::integer_rep_to_felt(integral)
     }));
     l2_weights.set_visibility(&ezkl::graph::Visibility::Private);
     l2_weights.reshape(&[CLASSES, LEN]).unwrap();
@@ -401,13 +410,13 @@ pub fn runconv() {
         l2_params: [l2_weights, l2_biases],
     };
 
-    let public_input: Tensor<i32> = vec![
-        -25124i32, -19304, -16668, -4399, -6209, -4548, -2317, -8349, -6117, -23461,
+    let public_input: Tensor<IntegerRep> = vec![
+        -25124, -19304, -16668, -4399, -6209, -4548, -2317, -8349, -6117, -23461,
     ]
     .into_iter()
     .into();
 
-    let pi_inner: Tensor<F> = public_input.map(i32_to_felt::<F>);
+    let pi_inner: Tensor<F> = public_input.map(integer_rep_to_felt::<F>);
 
     println!("MOCK PROVING");
     let now = Instant::now();

examples/mlp_4d_einsum.rs

@@ -2,7 +2,7 @@ use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::{
     ops::lookup::LookupOp, ops::poly::PolyOp, BaseConfig as PolyConfig, CheckMode,
 };
-use ezkl::fieldutils::i32_to_felt;
+use ezkl::fieldutils::{integer_rep_to_felt, IntegerRep};
 use ezkl::tensor::*;
 use halo2_proofs::dev::MockProver;
 use halo2_proofs::{
@@ -23,8 +23,8 @@ struct MyConfig {
 #[derive(Clone)]
 struct MyCircuit<
     const LEN: usize, //LEN = CHOUT x OH x OW flattened
-    const LOOKUP_MIN: i64,
-    const LOOKUP_MAX: i64,
+    const LOOKUP_MIN: IntegerRep,
+    const LOOKUP_MAX: IntegerRep,
 > {
     // Given the stateless MyConfig type information, a DNN trace is determined by its input and the parameters of its layers.
     // Computing the trace still requires a forward pass. The intermediate activations are stored only by the layouter.
@@ -34,7 +34,7 @@ struct MyCircuit<
     _marker: PhantomData<F>,
 }
 
-impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
+impl<const LEN: usize, const LOOKUP_MIN: IntegerRep, const LOOKUP_MAX: IntegerRep> Circuit<F>
     for MyCircuit<LEN, LOOKUP_MIN, LOOKUP_MAX>
 {
     type Config = MyConfig;
@@ -69,7 +69,7 @@ impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
                 &params,
                 (LOOKUP_MIN, LOOKUP_MAX),
                 K,
-                &LookupOp::ReLU,
+                &LookupOp::LeakyReLU { slope: 0.0.into() },
             )
             .unwrap();
 
@@ -108,7 +108,7 @@ impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
             .assign_region(
                 || "mlp_4d",
                 |region| {
-                    let mut region = RegionCtx::new(region, 0, 1);
+                    let mut region = RegionCtx::new(region, 0, 1, 1024, 2);
                     let x = config
                         .layer_config
                         .layout(
@@ -141,7 +141,11 @@ impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
                     println!("x shape: {:?}", x.dims());
                     let mut x = config
                         .layer_config
-                        .layout(&mut region, &[x], Box::new(LookupOp::ReLU))
+                        .layout(
+                            &mut region,
+                            &[x],
+                            Box::new(LookupOp::LeakyReLU { slope: 0.0.into() }),
+                        )
                         .unwrap()
                         .unwrap();
                     println!("3");
@@ -177,7 +181,11 @@ impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
                     println!("x shape: {:?}", x.dims());
                     let x = config
                         .layer_config
-                        .layout(&mut region, &[x], Box::new(LookupOp::ReLU))
+                        .layout(
+                            &mut region,
+                            &[x],
+                            Box::new(LookupOp::LeakyReLU { slope: 0.0.into() }),
+                        )
                         .unwrap();
                     println!("6");
                     println!("offset: {}", region.row());
@@ -215,33 +223,33 @@ pub fn runmlp() {
     #[cfg(not(target_arch = "wasm32"))]
     env_logger::init();
     // parameters
-    let mut l0_kernel: Tensor<F> = Tensor::<i32>::new(
+    let mut l0_kernel: Tensor<F> = Tensor::<IntegerRep>::new(
         Some(&[10, 0, 0, -1, 0, 10, 1, 0, 0, 1, 10, 0, 1, 0, 0, 10]),
         &[4, 4],
     )
     .unwrap()
-    .map(i32_to_felt);
+    .map(integer_rep_to_felt);
     l0_kernel.set_visibility(&ezkl::graph::Visibility::Private);
 
-    let mut l0_bias: Tensor<F> = Tensor::<i32>::new(Some(&[0, 0, 0, 1]), &[4, 1])
+    let mut l0_bias: Tensor<F> = Tensor::<IntegerRep>::new(Some(&[0, 0, 0, 1]), &[4, 1])
         .unwrap()
-        .map(i32_to_felt);
+        .map(integer_rep_to_felt);
     l0_bias.set_visibility(&ezkl::graph::Visibility::Private);
 
-    let mut l2_kernel: Tensor<F> = Tensor::<i32>::new(
+    let mut l2_kernel: Tensor<F> = Tensor::<IntegerRep>::new(
         Some(&[0, 3, 10, -1, 0, 10, 1, 0, 0, 1, 0, 12, 1, -2, 32, 0]),
         &[4, 4],
     )
     .unwrap()
-    .map(i32_to_felt);
+    .map(integer_rep_to_felt);
     l2_kernel.set_visibility(&ezkl::graph::Visibility::Private);
     // input data, with 1 padding to allow for bias
-    let input: Tensor<Value<F>> = Tensor::<i32>::new(Some(&[-30, -21, 11, 40]), &[4, 1])
+    let input: Tensor<Value<F>> = Tensor::<IntegerRep>::new(Some(&[-30, -21, 11, 40]), &[4, 1])
         .unwrap()
         .into();
-    let mut l2_bias: Tensor<F> = Tensor::<i32>::new(Some(&[0, 0, 0, 1]), &[4, 1])
+    let mut l2_bias: Tensor<F> = Tensor::<IntegerRep>::new(Some(&[0, 0, 0, 1]), &[4, 1])
         .unwrap()
-        .map(i32_to_felt);
+        .map(integer_rep_to_felt);
     l2_bias.set_visibility(&ezkl::graph::Visibility::Private);
 
     let circuit = MyCircuit::<4, -8192, 8192> {
@@ -251,12 +259,12 @@ pub fn runmlp() {
         _marker: PhantomData,
     };
 
-    let public_input: Vec<i32> = unsafe {
+    let public_input: Vec<IntegerRep> = unsafe {
         vec![
-            (531f32 / 128f32).round().to_int_unchecked::<i32>(),
-            (103f32 / 128f32).round().to_int_unchecked::<i32>(),
-            (4469f32 / 128f32).round().to_int_unchecked::<i32>(),
-            (2849f32 / 128f32).to_int_unchecked::<i32>(),
+            (531f32 / 128f32).round().to_int_unchecked::<IntegerRep>(),
+            (103f32 / 128f32).round().to_int_unchecked::<IntegerRep>(),
+            (4469f32 / 128f32).round().to_int_unchecked::<IntegerRep>(),
+            (2849f32 / 128f32).to_int_unchecked::<IntegerRep>(),
         ]
     };
 
@@ -265,7 +273,10 @@ pub fn runmlp() {
     let prover = MockProver::run(
         K as u32,
         &circuit,
-        vec![public_input.iter().map(|x| i32_to_felt::<F>(*x)).collect()],
+        vec![public_input
+            .iter()
+            .map(|x| integer_rep_to_felt::<F>(*x))
+            .collect()],
     )
     .unwrap();
     prover.assert_satisfied();

examples/notebooks/proof_splitting.ipynb

@@ -232,7 +232,7 @@
                 "run_args.param_visibility = \"fixed\"\n",
                 "run_args.output_visibility = \"public\"\n",
                 "run_args.input_scale = 2\n",
-                "run_args.logrows = 8\n",
+                "run_args.logrows = 15\n",
                 "\n",
                 "ezkl.get_srs(logrows=run_args.logrows, commitment=ezkl.PyCommitments.KZG)"
             ]
@@ -404,7 +404,7 @@
                 "run_args.output_visibility = \"polycommit\"\n",
                 "run_args.variables = [(\"batch_size\", 1)]\n",
                 "run_args.input_scale = 2\n",
-                "run_args.logrows = 8\n"
+                "run_args.logrows = 15\n"
             ]
         },
         {
@@ -466,7 +466,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.12.2"
+            "version": "3.12.5"
         },
         "orig_nbformat": 4
     },

examples/notebooks/reusable_verifier.ipynb

@@ -0,0 +1,339 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Reusable Verifiers \n",
+    "\n",
+    "This notebook demonstrates how to create and reuse the same set of separated verifiers for different models. Specifically, we will use the same verifier for the following four models:\n",
+    "\n",
+    "- `1l_mlp sigmoid`\n",
+    "- `1l_mlp relu`\n",
+    "- `1l_conv sigmoid`\n",
+    "- `1l_conv relu`\n",
+    "\n",
+    "When deploying EZKL verifiers on the blockchain, each associated model typically requires its own unique verifier, leading to increased on-chain state usage. \n",
+    "However, with the reusable verifier, we can deploy a single verifier that can be used to verify proofs for any valid H2 circuit. This notebook shows how to do so. \n",
+    "\n",
+    "By reusing the same verifier across multiple models, we significantly reduce the amount of state bloat on the blockchain. Instead of deploying a unique verifier for each model, we deploy a unique and much smaller verifying key artifact (VKA) contract for each model while sharing a common separated verifier. The VKA contains the VK for the model as well circuit specific metadata that was otherwise hardcoded into the stack of the original non-reusable verifier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.onnx\n",
+    "\n",
+    "# Define the models\n",
+    "class MLP_Sigmoid(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(MLP_Sigmoid, self).__init__()\n",
+    "        self.fc = nn.Linear(3, 3)\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.fc(x)\n",
+    "        x = self.sigmoid(x)\n",
+    "        return x\n",
+    "\n",
+    "class MLP_Relu(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(MLP_Relu, self).__init__()\n",
+    "        self.fc = nn.Linear(3, 3)\n",
+    "        self.relu = nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.fc(x)\n",
+    "        x = self.relu(x)\n",
+    "        return x\n",
+    "\n",
+    "class Conv_Sigmoid(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Conv_Sigmoid, self).__init__()\n",
+    "        self.conv = nn.Conv1d(1, 1, kernel_size=3, stride=1)\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv(x)\n",
+    "        x = self.sigmoid(x)\n",
+    "        return x\n",
+    "\n",
+    "class Conv_Relu(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Conv_Relu, self).__init__()\n",
+    "        self.conv = nn.Conv1d(1, 1, kernel_size=3, stride=1)\n",
+    "        self.relu = nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv(x)\n",
+    "        x = self.relu(x)\n",
+    "        return x\n",
+    "\n",
+    "# Instantiate the models\n",
+    "mlp_sigmoid = MLP_Sigmoid()\n",
+    "mlp_relu = MLP_Relu()\n",
+    "conv_sigmoid = Conv_Sigmoid()\n",
+    "conv_relu = Conv_Relu()\n",
+    "\n",
+    "# Dummy input tensor for mlp\n",
+    "dummy_input_mlp = torch.tensor([[-1.5737053155899048, -1.708398461341858, 0.19544155895709991]])\n",
+    "input_mlp_path = 'mlp_input.json'\n",
+    "\n",
+    "# Dummy input tensor for conv\n",
+    "dummy_input_conv = torch.tensor([[[1.4124163389205933, 0.6938204169273376, 1.0664031505584717]]])\n",
+    "input_conv_path = 'conv_input.json'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "names = ['mlp_sigmoid', 'mlp_relu', 'conv_sigmoid', 'conv_relu']\n",
+    "models = [mlp_sigmoid, mlp_relu, conv_sigmoid, conv_relu]\n",
+    "inputs = [dummy_input_mlp, dummy_input_mlp, dummy_input_conv, dummy_input_conv]\n",
+    "input_paths = [input_mlp_path, input_mlp_path, input_conv_path, input_conv_path]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import json\n",
+    "import torch\n",
+    "import ezkl\n",
+    "\n",
+    "for name, model, x, input_path in zip(names, models, inputs, input_paths):\n",
+    "    # Create a new directory for the model if it doesn't exist\n",
+    "    if not os.path.exists(name):\n",
+    "        os.mkdir(name)\n",
+    "    # Store the paths in each of their respective directories\n",
+    "    model_path = os.path.join(name, \"network.onnx\")\n",
+    "    compiled_model_path = os.path.join(name, \"network.compiled\")\n",
+    "    pk_path = os.path.join(name, \"test.pk\")\n",
+    "    vk_path = os.path.join(name, \"test.vk\")\n",
+    "    settings_path = os.path.join(name, \"settings.json\")\n",
+    "\n",
+    "    witness_path = os.path.join(name, \"witness.json\")\n",
+    "    sol_code_path = os.path.join(name, 'test.sol')\n",
+    "    sol_key_code_path = os.path.join(name, 'test_key.sol')\n",
+    "    abi_path = os.path.join(name, 'test.abi')\n",
+    "    proof_path = os.path.join(name, \"proof.json\")\n",
+    "\n",
+    "    # Flips the neural net into inference mode\n",
+    "    model.eval()\n",
+    "\n",
+    "    # Export the model\n",
+    "    torch.onnx.export(model, x, model_path, export_params=True, opset_version=10,\n",
+    "                      do_constant_folding=True, input_names=['input'],\n",
+    "                      output_names=['output'], dynamic_axes={'input': {0: 'batch_size'},\n",
+    "                                                              'output': {0: 'batch_size'}})\n",
+    "\n",
+    "    data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
+    "    data = dict(input_data=[data_array])\n",
+    "    json.dump(data, open(input_path, 'w'))\n",
+    "\n",
+    "    py_run_args = ezkl.PyRunArgs()\n",
+    "    py_run_args.input_visibility = \"private\"\n",
+    "    py_run_args.output_visibility = \"public\"\n",
+    "    py_run_args.param_visibility = \"fixed\"  # private by default\n",
+    "\n",
+    "    res = ezkl.gen_settings(model_path, settings_path, py_run_args=py_run_args)\n",
+    "    assert res == True\n",
+    "\n",
+    "    await ezkl.calibrate_settings(input_path, model_path, settings_path, \"resources\")\n",
+    "\n",
+    "    res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
+    "    assert res == True\n",
+    "\n",
+    "    res = await ezkl.get_srs(settings_path)\n",
+    "    assert res == True\n",
+    "\n",
+    "    # now generate the witness file\n",
+    "    res = await ezkl.gen_witness(input_path, compiled_model_path, witness_path)\n",
+    "    assert os.path.isfile(witness_path) == True\n",
+    "\n",
+    "    # SETUP \n",
+    "    # We recommend disabling selector compression for the setup as it decreases the size of the VK artifact\n",
+    "    res = ezkl.setup(compiled_model_path, vk_path, pk_path, disable_selector_compression=True)\n",
+    "    assert res == True\n",
+    "    assert os.path.isfile(vk_path)\n",
+    "    assert os.path.isfile(pk_path)\n",
+    "    assert os.path.isfile(settings_path)\n",
+    "\n",
+    "    # GENERATE A PROOF\n",
+    "    res = ezkl.prove(witness_path, compiled_model_path, pk_path, proof_path, \"single\")\n",
+    "    assert os.path.isfile(proof_path)\n",
+    "\n",
+    "    res = await ezkl.create_evm_verifier(vk_path, settings_path, sol_code_path, abi_path, reusable=True)\n",
+    "    assert res == True\n",
+    "\n",
+    "    res = await ezkl.create_evm_vka(vk_path, settings_path, sol_key_code_path, abi_path)\n",
+    "    assert res == True\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import subprocess\n",
+    "import time\n",
+    "\n",
+    "# make sure anvil is running locally\n",
+    "# $ anvil -p 3030\n",
+    "\n",
+    "RPC_URL = \"http://localhost:3030\"\n",
+    "\n",
+    "# Save process globally\n",
+    "anvil_process = None\n",
+    "\n",
+    "def start_anvil():\n",
+    "    global anvil_process\n",
+    "    if anvil_process is None:\n",
+    "        anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--code-size-limit=41943040\"])\n",
+    "        if anvil_process.returncode is not None:\n",
+    "            raise Exception(\"failed to start anvil process\")\n",
+    "        time.sleep(3)\n",
+    "\n",
+    "def stop_anvil():\n",
+    "    global anvil_process\n",
+    "    if anvil_process is not None:\n",
+    "        anvil_process.terminate()\n",
+    "        anvil_process = None\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Check that the generated verifiers are identical for all models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "start_anvil()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import filecmp\n",
+    "\n",
+    "def compare_files(file1, file2):\n",
+    "    return filecmp.cmp(file1, file2, shallow=False)\n",
+    "\n",
+    "sol_code_path_0 = os.path.join(\"mlp_sigmoid\", 'test.sol')\n",
+    "sol_code_path_1 = os.path.join(\"mlp_relu\", 'test.sol')\n",
+    "\n",
+    "sol_code_path_2 = os.path.join(\"conv_sigmoid\", 'test.sol')\n",
+    "sol_code_path_3 = os.path.join(\"conv_relu\", 'test.sol')\n",
+    "\n",
+    "\n",
+    "assert compare_files(sol_code_path_0, sol_code_path_1) == True\n",
+    "assert compare_files(sol_code_path_2, sol_code_path_3) == True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we deploy separate verifier that will be shared by the four models. We picked the `1l_mlp sigmoid` model as an example but you could have used any of the generated verifiers since they are all identical. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os \n",
+    "addr_path_verifier = \"addr_verifier.txt\"\n",
+    "sol_code_path = os.path.join(\"mlp_sigmoid\", 'test.sol')\n",
+    "\n",
+    "res = await ezkl.deploy_evm(\n",
+    "    addr_path_verifier,\n",
+    "    sol_code_path,\n",
+    "    'http://127.0.0.1:3030',\n",
+    "    \"verifier/reusable\"\n",
+    ")\n",
+    "\n",
+    "assert res == True\n",
+    "\n",
+    "with open(addr_path_verifier, 'r') as file:\n",
+    "    addr = file.read().rstrip()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally we deploy each of the unique VK-artifacts and verify them using the shared verifier deployed in the previous step."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for name in names:\n",
+    "    addr_path_vk = \"addr_vk.txt\"\n",
+    "    sol_key_code_path = os.path.join(name, 'test_key.sol')\n",
+    "    res = await ezkl.deploy_evm(addr_path_vk, sol_key_code_path, 'http://127.0.0.1:3030', \"vka\")\n",
+    "    assert res == True\n",
+    "\n",
+    "    with open(addr_path_vk, 'r') as file:\n",
+    "        addr_vk = file.read().rstrip()\n",
+    "        \n",
+    "    proof_path = os.path.join(name, \"proof.json\")\n",
+    "    sol_code_path = os.path.join(name, 'vk.sol')\n",
+    "    res = await ezkl.verify_evm(\n",
+    "        addr,\n",
+    "        proof_path,\n",
+    "        \"http://127.0.0.1:3030\",\n",
+    "        addr_vk = addr_vk\n",
+    "    )\n",
+    "    assert res == True"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".env",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

examples/notebooks/svm.ipynb

@@ -39,7 +39,7 @@
                 "import json\n",
                 "import numpy as np\n",
                 "from sklearn.svm import SVC\n",
-                "import sk2torch\n",
+                "from hummingbird.ml import convert\n",
                 "import torch\n",
                 "import ezkl\n",
                 "import os\n",
@@ -59,11 +59,11 @@
                 "# Train an SVM on the data and wrap it in PyTorch.\n",
                 "sk_model = SVC(probability=True)\n",
                 "sk_model.fit(xs, ys)\n",
-                "model = sk2torch.wrap(sk_model)\n",
-                "\n",
+                "model = convert(sk_model, \"torch\").model\n",
                 "\n",
                 "\n",
                 "\n",
+                "model\n",
                 "\n"
             ]
         },
@@ -84,33 +84,6 @@
                 "data_path = os.path.join('input.json')"
             ]
         },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "7f0ca328",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import matplotlib.pyplot as plt\n",
-                "# Create a coordinate grid to compute a vector field on.\n",
-                "spaced = np.linspace(-2, 2, num=25)\n",
-                "grid_xs = torch.tensor([[x, y] for x in spaced for y in spaced], requires_grad=True)\n",
-                "\n",
-                "\n",
-                "# Compute the gradients of the SVM output.\n",
-                "outputs = model.predict_proba(grid_xs)[:, 1]\n",
-                "(input_grads,) = torch.autograd.grad(outputs.sum(), (grid_xs,))\n",
-                "\n",
-                "\n",
-                "# Create a quiver plot of the vector field.\n",
-                "plt.quiver(\n",
-                "    grid_xs[:, 0].detach().numpy(),\n",
-                "    grid_xs[:, 1].detach().numpy(),\n",
-                "    input_grads[:, 0].detach().numpy(),\n",
-                "    input_grads[:, 1].detach().numpy(),\n",
-                ")\n"
-            ]
-        },
         {
             "cell_type": "code",
             "execution_count": null,
@@ -119,14 +92,14 @@
             "outputs": [],
             "source": [
                 "\n",
-                "\n",
+                "spaced = np.linspace(-2, 2, num=25)\n",
+                "grid_xs = torch.tensor([[x, y] for x in spaced for y in spaced], requires_grad=True)\n",
                 "# export to onnx format\n",
                 "# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
                 "\n",
                 "# Input to the model\n",
                 "shape = xs.shape[1:]\n",
                 "x = grid_xs[0:1]\n",
-                "torch_out = model.predict(x)\n",
                 "# Export the model\n",
                 "torch.onnx.export(model,               # model being run\n",
                 "                  # model input (or a tuple for multiple inputs)\n",
@@ -143,9 +116,7 @@
                 "\n",
                 "d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
                 "\n",
-                "data = dict(input_shapes=[shape],\n",
-                "            input_data=[d],\n",
-                "            output_data=[o.reshape([-1]).tolist() for o in torch_out])\n",
+                "data = dict(input_data=[d])\n",
                 "\n",
                 "# Serialize data into file:\n",
                 "json.dump(data, open(\"input.json\", 'w'))\n"
@@ -167,6 +138,7 @@
         {
             "cell_type": "code",
             "execution_count": null,
+            "id": "0bee4d7f",
             "metadata": {},
             "outputs": [],
             "source": [
@@ -220,7 +192,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 10,
+            "execution_count": null,
             "id": "b1c561a8",
             "metadata": {},
             "outputs": [],
@@ -441,9 +413,9 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.3"
         }
     },
     "nbformat": 4,
     "nbformat_minor": 5
-}
+}

examples/onnx/1l_conv_transpose/settings.json

@@ -0,0 +1 @@
+{"run_args":{"tolerance":{"val":0.0,"scale":1.0},"input_scale":7,"param_scale":7,"scale_rebase_multiplier":10,"lookup_range":[0,0],"logrows":13,"variables":[["batch_size",1]],"input_visibility":"Private","output_visibility":"Public","param_visibility":"Private"},"num_constraints":5619,"total_const_size":513,"model_instance_shapes":[[1,3,10,10]],"model_output_scales":[14],"model_input_scales":[7],"module_sizes":{"kzg":[],"poseidon":[0,[0]],"elgamal":[0,[0]]},"required_lookups":[],"check_mode":"UNSAFE","version":"0.0.0","num_blinding_factors":null}

examples/onnx/boolean/gen.py

@@ -9,7 +9,9 @@ class MyModel(nn.Module):
         super(MyModel, self).__init__()
 
     def forward(self, w, x, y, z):
-        return [((x & y)) == (x & (y | (z ^ w)))]
+        a = (x & y)
+        b = (y & (z ^ w))
+        return [a & b]
 
 
 circuit = MyModel()

examples/onnx/boolean/input.json

@@ -1 +1 @@
-{"input_data": [[false, true, false], [true, false, false], [true, false, false], [false, false, false]]}
+{"input_data": [[false, true, true], [false, true, true], [true, false, false], [false, true, true]]}

examples/onnx/boolean/network.onnx

@@ -1,21 +1,17 @@
-pytorch1.12.1:«
-+
+pytorch2.2.2:„
+*
 input1
-input2
-onnx::Equal_4And_0"And
+input2
+/And_output_0/And"And
 )
-input3
-input
-onnx::Or_5Xor_1"Xor
+input3
+input
 /Xor_output_0/Xor"Xor
-input2
-
-onnx::Or_5onnx::And_6Or_2"Or
-0
-input1
-onnx::And_6
-onnx::Equal_7And_3"And
-6
+5
+input2
+
+/Xor_output_0/And_1_output_0/And_1"And
+5
 
 /And_output_0
 /And_1_output_0output/And_2"And

examples/onnx/smallworm/.gitattributes

@@ -0,0 +1 @@
+network.onnx filter=lfs diff=lfs merge=lfs -text

examples/onnx/smallworm/Readme.md

@@ -0,0 +1,47 @@
+## The worm 
+
+This is an onnx file for a [WormVAE](https://github.com/TuragaLab/wormvae?tab=readme-ov-file) model, which is a VAE / latent-space representation of the C. elegans connectome.
+
+The model "is a large-scale latent variable model with a very high-dimensional latent space
+consisting of voltage dynamics of 300 neurons over 5 minutes of time at the simulation frequency
+of 160 Hz. The generative model for these latent variables is described by stochastic differential
+equations modeling the nonlinear dynamics of the network activity." (see [here](https://openreview.net/pdf?id=CJzi3dRlJE-)). 
+
+In effect this is a generative model for a worm's voltage dynamics, which can be used to generate new worm-like voltage dynamics given previous connectome state.
+
+Using ezkl you can create a zk circuit equivalent to the wormvae model, allowing you to "prove" execution of the worm model. If you're feeling particularly adventurous, you can also use the zk circuit to generate new worm-state that can be verified on chain. 
+
+To do so you'll first want to fetch the files using git-lfs (as the onnx file is too large to be stored in git). 
+
+```bash
+git lfs fetch --all
+```
+
+You'll then want to use the usual ezkl loop to generate the zk circuit. We recommend using fixed visibility for the model parameters, as the model is quite large and this will prune the circuit significantly. 
+
+```bash
+ezkl gen-settings --param-visibility=fixed
+cp input.json calibration.json
+ezkl calibrate-settings
+ezkl compile-circuit
+ezkl gen-witness
+ezkl prove
+```
+
+You might also need to aggregate the proof to get it to fit on chain.
+
+```bash
+ezkl aggregate
+```
+
+You can then create a smart contract that verifies this aggregate proof
+
+```bash
+ezkl create-evm-verifier-aggr
+```
+
+This can then be deployed on the chain of your choice.
+
+
+> Note: the model is large and thus we recommend a machine with at least 512GB of RAM to run the above commands. If you're ever compute constrained you can always use the lilith service to generate the zk circuit. Message us on discord or telegram for more details :)
+

examples/onnx/smallworm/network.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f88c5901d3768ec21e3cf2f2840d255e84fa13c364df86b24d960cca3333769
+size 82095882

examples/onnx/smallworm/settings.json

@@ -0,0 +1 @@
+{"run_args":{"tolerance":{"val":0.0,"scale":1.0},"input_scale":0,"param_scale":6,"scale_rebase_multiplier":1,"lookup_range":[-32768,32768],"logrows":17,"variables":[["batch_size",1]],"input_visibility":"Private","output_visibility":"Public","param_visibility":"Fixed"},"num_constraints":367422820,"total_const_size":365577160,"model_instance_shapes":[[1,300,1200]],"model_output_scales":[6],"model_input_scales":[0,0,0],"module_sizes":{"kzg":[],"poseidon":[0,[0]],"elgamal":[0,[0]]},"required_lookups":[{"Div":{"denom":64.0}},"ReLU",{"Ln":{"scale":64.0}},{"Exp":{"scale":64.0}}],"check_mode":"UNSAFE","version":"0.0.0","num_blinding_factors":null}

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

@@ -9,7 +9,6 @@ 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,
@@ -66,7 +65,7 @@ async function verify(
     vkAddress = new Uint8Array(uint8Array.buffer);
 
     // convert uitn8array of length
-    error('vkAddress', vkAddress)
+    console.error('vkAddress', vkAddress)
   }
   const data = encodeVerifierCalldata(proof, vkAddress)
 

rust-toolchain

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2024-02-06"
+channel = "nightly-2024-07-18"
 components = ["rustfmt", "clippy"]

src/bin/ezkl.rs

@@ -1,4 +1,7 @@
 // ignore file if compiling for wasm
+#[global_allocator]
+#[cfg(not(target_arch = "wasm32"))]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
 #[cfg(not(target_arch = "wasm32"))]
 use clap::{CommandFactory, Parser};

src/circuit/ops/chip.rs

@@ -22,7 +22,7 @@ use crate::{
         table::{Range, RangeCheck, Table},
         utils,
     },
-    tensor::{IntoI64, Tensor, TensorType, ValTensor, VarTensor},
+    tensor::{Tensor, TensorType, ValTensor, VarTensor},
 };
 use std::{collections::BTreeMap, marker::PhantomData};
 
@@ -327,7 +327,7 @@ pub struct BaseConfig<F: PrimeField + TensorType + PartialOrd> {
     _marker: PhantomData<F>,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> BaseConfig<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> 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 {
         Self {

src/circuit/ops/errors.rs

@@ -1,6 +1,6 @@
 use std::convert::Infallible;
 
-use crate::tensor::TensorError;
+use crate::{fieldutils::IntegerRep, tensor::TensorError};
 use halo2_proofs::plonk::Error as PlonkError;
 use thiserror::Error;
 
@@ -57,7 +57,7 @@ pub enum CircuitError {
     InvalidConversion(#[from] Infallible),
     /// Invalid min/max lookup range
     #[error("invalid min/max lookup range: min: {0}, max: {1}")]
-    InvalidMinMaxRange(i64, i64),
+    InvalidMinMaxRange(IntegerRep, IntegerRep),
     /// Missing product in einsum
     #[error("missing product in einsum")]
     MissingEinsumProduct,
@@ -81,7 +81,7 @@ pub enum CircuitError {
     MissingSelectors(String),
     /// Table lookup error
     #[error("value ({0}) out of range: ({1}, {2})")]
-    TableOOR(i64, i64, i64),
+    TableOOR(IntegerRep, IntegerRep, IntegerRep),
     /// Loookup not configured
     #[error("lookup not configured: {0}")]
     LookupNotConfigured(String),
@@ -91,4 +91,7 @@ pub enum CircuitError {
     /// Missing layout
     #[error("missing layout for op: {0}")]
     MissingLayout(String),
+    #[error("[io] {0}")]
+    /// IO error
+    IoError(#[from] std::io::Error),
 }

src/circuit/ops/hybrid.rs

@@ -1,7 +1,7 @@
 use super::*;
 use crate::{
     circuit::{layouts, utils, Tolerance},
-    fieldutils::i64_to_felt,
+    fieldutils::integer_rep_to_felt,
     graph::multiplier_to_scale,
     tensor::{self, Tensor, TensorType, ValTensor},
 };
@@ -71,12 +71,17 @@ pub enum HybridOp {
     },
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for HybridOp {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for HybridOp {
     ///
     fn requires_homogenous_input_scales(&self) -> Vec<usize> {
         match self {
-            HybridOp::Greater | HybridOp::Less | HybridOp::Equals => vec![0, 1],
-            HybridOp::GreaterEqual | HybridOp::LessEqual => vec![0, 1],
+            HybridOp::Greater { .. }
+            | HybridOp::Less { .. }
+            | HybridOp::Equals { .. }
+            | HybridOp::GreaterEqual { .. }
+            | HybridOp::LessEqual { .. } => {
+                vec![0, 1]
+            }
             _ => vec![],
         }
     }
@@ -135,10 +140,10 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
                 )
             }
             HybridOp::RangeCheck(p) => format!("RANGECHECK (tol={:?})", p),
-            HybridOp::Greater => "GREATER".into(),
-            HybridOp::GreaterEqual => "GREATEREQUAL".into(),
-            HybridOp::Less => "LESS".into(),
-            HybridOp::LessEqual => "LESSEQUAL".into(),
+            HybridOp::Greater => "GREATER".to_string(),
+            HybridOp::GreaterEqual => "GREATEREQUAL".to_string(),
+            HybridOp::Less => "LESS".to_string(),
+            HybridOp::LessEqual => "LESSEQUAL".to_string(),
             HybridOp::Equals => "EQUALS".into(),
             HybridOp::Gather { dim, .. } => format!("GATHER (dim={})", dim),
             HybridOp::TopK { k, dim, largest } => {
@@ -184,8 +189,8 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
                         config,
                         region,
                         values[..].try_into()?,
-                        i64_to_felt(input_scale.0 as i64),
-                        i64_to_felt(output_scale.0 as i64),
+                        integer_rep_to_felt(input_scale.0 as i128),
+                        integer_rep_to_felt(output_scale.0 as i128),
                     )?
                 } else {
                     layouts::nonlinearity(
@@ -209,7 +214,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
                         config,
                         region,
                         values[..].try_into()?,
-                        i64_to_felt(denom.0 as i64),
+                        integer_rep_to_felt(denom.0 as i128),
                     )?
                 } else {
                     layouts::nonlinearity(

src/circuit/ops/lookup.rs

@@ -3,9 +3,9 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     circuit::{layouts, table::Range, utils},
-    fieldutils::{felt_to_i64, i64_to_felt},
+    fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep},
     graph::multiplier_to_scale,
-    tensor::{self, IntoI64, Tensor, TensorError, TensorType},
+    tensor::{self, Tensor, TensorError, TensorType},
 };
 
 use super::Op;
@@ -15,14 +15,12 @@ use halo2curves::ff::PrimeField;
 /// An enum representing the operations that can be used to express more complex operations via accumulation
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Deserialize, Serialize)]
 pub enum LookupOp {
-    Abs,
     Div {
         denom: utils::F32,
     },
     Cast {
         scale: utils::F32,
     },
-    ReLU,
     Max {
         scale: utils::F32,
         a: utils::F32,
@@ -104,19 +102,6 @@ pub enum LookupOp {
     Erf {
         scale: utils::F32,
     },
-    GreaterThan {
-        a: utils::F32,
-    },
-    LessThan {
-        a: utils::F32,
-    },
-    GreaterThanEqual {
-        a: utils::F32,
-    },
-    LessThanEqual {
-        a: utils::F32,
-    },
-    Sign,
     KroneckerDelta,
     Pow {
         scale: utils::F32,
@@ -131,109 +116,165 @@ impl LookupOp {
     /// Returns the range of values that can be represented by the table
     pub fn bit_range(max_len: usize) -> Range {
         let range = (max_len - 1) as f64 / 2_f64;
-        let range = range as i64;
+        let range = range as IntegerRep;
         (-range, range)
     }
 
-    /// Matches a [Op] to an operation in the `tensor::ops` module.
-    pub(crate) fn f<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64>(
-        &self,
-        x: &[Tensor<F>],
-    ) -> Result<ForwardResult<F>, TensorError> {
-        let x = x[0].clone().map(|x| felt_to_i64(x));
-        let res = match &self {
-            LookupOp::Abs => Ok(tensor::ops::abs(&x)?),
-            LookupOp::Ceil { scale } => Ok(tensor::ops::nonlinearities::ceil(&x, scale.into())),
-            LookupOp::Floor { scale } => Ok(tensor::ops::nonlinearities::floor(&x, scale.into())),
-            LookupOp::Round { scale } => Ok(tensor::ops::nonlinearities::round(&x, scale.into())),
-            LookupOp::RoundHalfToEven { scale } => Ok(
-                tensor::ops::nonlinearities::round_half_to_even(&x, scale.into()),
-            ),
-            LookupOp::Pow { scale, a } => Ok(tensor::ops::nonlinearities::pow(
-                &x,
-                scale.0.into(),
-                a.0.into(),
-            )),
-            LookupOp::KroneckerDelta => Ok(tensor::ops::nonlinearities::kronecker_delta(&x)),
-            LookupOp::Max { scale, a } => Ok(tensor::ops::nonlinearities::max(
-                &x,
-                scale.0.into(),
-                a.0.into(),
-            )),
-            LookupOp::Min { scale, a } => Ok(tensor::ops::nonlinearities::min(
-                &x,
-                scale.0.into(),
-                a.0.into(),
-            )),
-            LookupOp::Sign => Ok(tensor::ops::nonlinearities::sign(&x)),
-            LookupOp::LessThan { a } => Ok(tensor::ops::nonlinearities::less_than(
-                &x,
-                f32::from(*a).into(),
-            )),
-            LookupOp::LessThanEqual { a } => Ok(tensor::ops::nonlinearities::less_than_equal(
-                &x,
-                f32::from(*a).into(),
-            )),
-            LookupOp::GreaterThan { a } => Ok(tensor::ops::nonlinearities::greater_than(
-                &x,
-                f32::from(*a).into(),
-            )),
-            LookupOp::GreaterThanEqual { a } => Ok(
-                tensor::ops::nonlinearities::greater_than_equal(&x, f32::from(*a).into()),
-            ),
-            LookupOp::Div { denom } => Ok(tensor::ops::nonlinearities::const_div(
-                &x,
-                f32::from(*denom).into(),
-            )),
-            LookupOp::Cast { scale } => Ok(tensor::ops::nonlinearities::const_div(
-                &x,
-                f32::from(*scale).into(),
-            )),
+    /// as path
+    pub fn as_path(&self) -> String {
+        match self {
+            LookupOp::Ceil { scale } => format!("ceil_{}", scale),
+            LookupOp::Floor { scale } => format!("floor_{}", scale),
+            LookupOp::Round { scale } => format!("round_{}", scale),
+            LookupOp::RoundHalfToEven { scale } => format!("round_half_to_even_{}", scale),
+            LookupOp::Pow { scale, a } => format!("pow_{}_{}", scale, a),
+            LookupOp::KroneckerDelta => "kronecker_delta".into(),
+            LookupOp::Max { scale, a } => format!("max_{}_{}", scale, a),
+            LookupOp::Min { scale, a } => format!("min_{}_{}", scale, a),
+            LookupOp::Div { denom } => format!("div_{}", denom),
+            LookupOp::Cast { scale } => format!("cast_{}", scale),
             LookupOp::Recip {
                 input_scale,
                 output_scale,
-            } => Ok(tensor::ops::nonlinearities::recip(
-                &x,
-                input_scale.into(),
-                output_scale.into(),
-            )),
-            LookupOp::ReLU => Ok(tensor::ops::nonlinearities::leakyrelu(&x, 0_f64)),
+            } => format!("recip_{}_{}", input_scale, output_scale),
+            LookupOp::LeakyReLU { slope: a } => format!("leaky_relu_{}", a),
+            LookupOp::Sigmoid { scale } => format!("sigmoid_{}", scale),
+            LookupOp::Sqrt { scale } => format!("sqrt_{}", scale),
+            LookupOp::Rsqrt { scale } => format!("rsqrt_{}", scale),
+            LookupOp::Erf { scale } => format!("erf_{}", scale),
+            LookupOp::Exp { scale } => format!("exp_{}", scale),
+            LookupOp::Ln { scale } => format!("ln_{}", scale),
+            LookupOp::Cos { scale } => format!("cos_{}", scale),
+            LookupOp::ACos { scale } => format!("acos_{}", scale),
+            LookupOp::Cosh { scale } => format!("cosh_{}", scale),
+            LookupOp::ACosh { scale } => format!("acosh_{}", scale),
+            LookupOp::Sin { scale } => format!("sin_{}", scale),
+            LookupOp::ASin { scale } => format!("asin_{}", scale),
+            LookupOp::Sinh { scale } => format!("sinh_{}", scale),
+            LookupOp::ASinh { scale } => format!("asinh_{}", scale),
+            LookupOp::Tan { scale } => format!("tan_{}", scale),
+            LookupOp::ATan { scale } => format!("atan_{}", scale),
+            LookupOp::ATanh { scale } => format!("atanh_{}", scale),
+            LookupOp::Tanh { scale } => format!("tanh_{}", scale),
+            LookupOp::HardSwish { scale } => format!("hardswish_{}", scale),
+        }
+    }
 
-            LookupOp::LeakyReLU { slope: a } => {
-                Ok(tensor::ops::nonlinearities::leakyrelu(&x, a.0.into()))
-            }
-            LookupOp::Sigmoid { scale } => {
-                Ok(tensor::ops::nonlinearities::sigmoid(&x, scale.into()))
-            }
-            LookupOp::Sqrt { scale } => Ok(tensor::ops::nonlinearities::sqrt(&x, scale.into())),
-            LookupOp::Rsqrt { scale } => Ok(tensor::ops::nonlinearities::rsqrt(&x, scale.into())),
-            LookupOp::Erf { scale } => Ok(tensor::ops::nonlinearities::erffunc(&x, scale.into())),
-            LookupOp::Exp { scale } => Ok(tensor::ops::nonlinearities::exp(&x, scale.into())),
-            LookupOp::Ln { scale } => Ok(tensor::ops::nonlinearities::ln(&x, scale.into())),
-            LookupOp::Cos { scale } => Ok(tensor::ops::nonlinearities::cos(&x, scale.into())),
-            LookupOp::ACos { scale } => Ok(tensor::ops::nonlinearities::acos(&x, scale.into())),
-            LookupOp::Cosh { scale } => Ok(tensor::ops::nonlinearities::cosh(&x, scale.into())),
-            LookupOp::ACosh { scale } => Ok(tensor::ops::nonlinearities::acosh(&x, scale.into())),
-            LookupOp::Sin { scale } => Ok(tensor::ops::nonlinearities::sin(&x, scale.into())),
-            LookupOp::ASin { scale } => Ok(tensor::ops::nonlinearities::asin(&x, scale.into())),
-            LookupOp::Sinh { scale } => Ok(tensor::ops::nonlinearities::sinh(&x, scale.into())),
-            LookupOp::ASinh { scale } => Ok(tensor::ops::nonlinearities::asinh(&x, scale.into())),
-            LookupOp::Tan { scale } => Ok(tensor::ops::nonlinearities::tan(&x, scale.into())),
-            LookupOp::ATan { scale } => Ok(tensor::ops::nonlinearities::atan(&x, scale.into())),
-            LookupOp::ATanh { scale } => Ok(tensor::ops::nonlinearities::atanh(&x, scale.into())),
-            LookupOp::Tanh { scale } => Ok(tensor::ops::nonlinearities::tanh(&x, scale.into())),
-            LookupOp::HardSwish { scale } => {
-                Ok(tensor::ops::nonlinearities::hardswish(&x, scale.into()))
-            }
-        }?;
+    /// Matches a [Op] to an operation in the `tensor::ops` module.
+    pub(crate) fn f<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
+        &self,
+        x: &[Tensor<F>],
+    ) -> Result<ForwardResult<F>, TensorError> {
+        let x = x[0].clone().map(|x| felt_to_integer_rep(x));
+        let res =
+            match &self {
+                LookupOp::Ceil { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::ceil(&x, scale.into()))
+                }
+                LookupOp::Floor { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::floor(&x, scale.into()))
+                }
+                LookupOp::Round { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::round(&x, scale.into()))
+                }
+                LookupOp::RoundHalfToEven { scale } => Ok::<_, TensorError>(
+                    tensor::ops::nonlinearities::round_half_to_even(&x, scale.into()),
+                ),
+                LookupOp::Pow { scale, a } => Ok::<_, TensorError>(
+                    tensor::ops::nonlinearities::pow(&x, scale.0.into(), a.0.into()),
+                ),
+                LookupOp::KroneckerDelta => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::kronecker_delta(&x))
+                }
+                LookupOp::Max { scale, a } => Ok::<_, TensorError>(
+                    tensor::ops::nonlinearities::max(&x, scale.0.into(), a.0.into()),
+                ),
+                LookupOp::Min { scale, a } => Ok::<_, TensorError>(
+                    tensor::ops::nonlinearities::min(&x, scale.0.into(), a.0.into()),
+                ),
+                LookupOp::Div { denom } => Ok::<_, TensorError>(
+                    tensor::ops::nonlinearities::const_div(&x, f32::from(*denom).into()),
+                ),
+                LookupOp::Cast { scale } => Ok::<_, TensorError>(
+                    tensor::ops::nonlinearities::const_div(&x, f32::from(*scale).into()),
+                ),
+                LookupOp::Recip {
+                    input_scale,
+                    output_scale,
+                } => Ok::<_, TensorError>(tensor::ops::nonlinearities::recip(
+                    &x,
+                    input_scale.into(),
+                    output_scale.into(),
+                )),
+                LookupOp::LeakyReLU { slope: a } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::leakyrelu(&x, a.0.into()))
+                }
+                LookupOp::Sigmoid { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::sigmoid(&x, scale.into()))
+                }
+                LookupOp::Sqrt { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::sqrt(&x, scale.into()))
+                }
+                LookupOp::Rsqrt { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::rsqrt(&x, scale.into()))
+                }
+                LookupOp::Erf { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::erffunc(&x, scale.into()))
+                }
+                LookupOp::Exp { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::exp(&x, scale.into()))
+                }
+                LookupOp::Ln { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::ln(&x, scale.into()))
+                }
+                LookupOp::Cos { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::cos(&x, scale.into()))
+                }
+                LookupOp::ACos { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::acos(&x, scale.into()))
+                }
+                LookupOp::Cosh { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::cosh(&x, scale.into()))
+                }
+                LookupOp::ACosh { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::acosh(&x, scale.into()))
+                }
+                LookupOp::Sin { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::sin(&x, scale.into()))
+                }
+                LookupOp::ASin { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::asin(&x, scale.into()))
+                }
+                LookupOp::Sinh { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::sinh(&x, scale.into()))
+                }
+                LookupOp::ASinh { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::asinh(&x, scale.into()))
+                }
+                LookupOp::Tan { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::tan(&x, scale.into()))
+                }
+                LookupOp::ATan { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::atan(&x, scale.into()))
+                }
+                LookupOp::ATanh { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::atanh(&x, scale.into()))
+                }
+                LookupOp::Tanh { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::tanh(&x, scale.into()))
+                }
+                LookupOp::HardSwish { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::hardswish(&x, scale.into()))
+                }
+            }?;
 
-        let output = res.map(|x| i64_to_felt(x));
+        let output = res.map(|x| integer_rep_to_felt(x));
 
         Ok(ForwardResult { output })
     }
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for LookupOp {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for LookupOp {
     /// Returns a reference to the Any trait.
     fn as_any(&self) -> &dyn Any {
         self
@@ -242,7 +283,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
     /// Returns the name of the operation
     fn as_string(&self) -> String {
         match self {
-            LookupOp::Abs => "ABS".into(),
             LookupOp::Ceil { scale } => format!("CEIL(scale={})", scale),
             LookupOp::Floor { scale } => format!("FLOOR(scale={})", scale),
             LookupOp::Round { scale } => format!("ROUND(scale={})", scale),
@@ -251,11 +291,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
             LookupOp::KroneckerDelta => "K_DELTA".into(),
             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::Recip {
                 input_scale,
                 output_scale,
@@ -266,7 +301,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
             LookupOp::Div { denom, .. } => format!("DIV(denom={})", denom),
             LookupOp::Cast { scale } => format!("CAST(scale={})", scale),
             LookupOp::Ln { scale } => format!("LN(scale={})", scale),
-            LookupOp::ReLU => "RELU".to_string(),
             LookupOp::LeakyReLU { slope: a } => format!("L_RELU(slope={})", a),
             LookupOp::Sigmoid { scale } => format!("SIGMOID(scale={})", scale),
             LookupOp::Sqrt { scale } => format!("SQRT(scale={})", scale),
@@ -311,12 +345,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
                 in_scale + multiplier_to_scale(1. / scale.0 as f64)
             }
             LookupOp::Recip { output_scale, .. } => multiplier_to_scale(output_scale.into()),
-            LookupOp::Sign
-            | LookupOp::GreaterThan { .. }
-            | LookupOp::LessThan { .. }
-            | LookupOp::GreaterThanEqual { .. }
-            | LookupOp::LessThanEqual { .. }
-            | LookupOp::KroneckerDelta => 0,
+            LookupOp::KroneckerDelta => 0,
             _ => inputs_scale[0],
         };
         Ok(scale)

src/circuit/ops/mod.rs

@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     graph::quantize_tensor,
-    tensor::{self, IntoI64, Tensor, TensorType, ValTensor},
+    tensor::{self, Tensor, TensorType, ValTensor},
 };
 use halo2curves::ff::PrimeField;
 
@@ -31,12 +31,12 @@ pub use errors::CircuitError;
 
 /// A struct representing the result of a forward pass.
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-pub struct ForwardResult<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> {
+pub struct ForwardResult<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
     pub(crate) output: Tensor<F>,
 }
 
 /// A trait representing operations that can be represented as constraints in a circuit.
-pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64>:
+pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>:
     std::fmt::Debug + Send + Sync + Any
 {
     /// Returns a string representation of the operation.
@@ -75,7 +75,7 @@ pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64
     fn as_any(&self) -> &dyn Any;
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Clone for Box<dyn Op<F>> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Clone for Box<dyn Op<F>> {
     fn clone(&self) -> Self {
         self.clone_dyn()
     }
@@ -142,7 +142,7 @@ pub struct Input {
     pub datum_type: InputType,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for Input {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input {
     fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
         Ok(self.scale)
     }
@@ -197,7 +197,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct Unknown;
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for Unknown {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Unknown {
     fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
         Ok(0)
     }
@@ -224,7 +224,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
 
 ///
 #[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> {
+pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
     ///
     pub quantized_values: Tensor<F>,
     ///
@@ -234,7 +234,7 @@ pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash +
     pub pre_assigned_val: Option<ValTensor<F>>,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Constant<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Constant<F> {
     ///
     pub fn new(quantized_values: Tensor<F>, raw_values: Tensor<f32>) -> Self {
         Self {
@@ -267,8 +267,7 @@ impl<
             + PartialOrd
             + std::hash::Hash
             + Serialize
-            + for<'de> Deserialize<'de>
-            + IntoI64,
+            + for<'de> Deserialize<'de>,
     > Op<F> for Constant<F>
 {
     fn as_any(&self) -> &dyn Any {

src/circuit/ops/poly.rs

@@ -9,6 +9,9 @@ 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 {
+    ReLU,
+    Abs,
+    Sign,
     GatherElements {
         dim: usize,
         constant_idx: Option<Tensor<usize>>,
@@ -33,6 +36,7 @@ pub enum PolyOp {
     Conv {
         padding: Vec<(usize, usize)>,
         stride: Vec<usize>,
+        group: usize,
     },
     Downsample {
         axis: usize,
@@ -43,6 +47,7 @@ pub enum PolyOp {
         padding: Vec<(usize, usize)>,
         output_padding: Vec<usize>,
         stride: Vec<usize>,
+        group: usize,
     },
     Add,
     Sub,
@@ -97,8 +102,7 @@ impl<
             + PartialOrd
             + std::hash::Hash
             + Serialize
-            + for<'de> Deserialize<'de>
-            + IntoI64,
+            + for<'de> Deserialize<'de>,
     > Op<F> for PolyOp
 {
     /// Returns a reference to the Any trait.
@@ -108,6 +112,9 @@ impl<
 
     fn as_string(&self) -> String {
         match &self {
+            PolyOp::Abs => "ABS".to_string(),
+            PolyOp::Sign => "SIGN".to_string(),
+            PolyOp::ReLU => "RELU".to_string(),
             PolyOp::GatherElements { dim, constant_idx } => format!(
                 "GATHERELEMENTS (dim={}, constant_idx{})",
                 dim,
@@ -148,17 +155,25 @@ impl<
             PolyOp::Sum { axes } => format!("SUM (axes={:?})", axes),
             PolyOp::Prod { .. } => "PROD".into(),
             PolyOp::Pow(_) => "POW".into(),
-            PolyOp::Conv { stride, padding } => {
-                format!("CONV (stride={:?}, padding={:?})", stride, padding)
+            PolyOp::Conv {
+                stride,
+                padding,
+                group,
+            } => {
+                format!(
+                    "CONV (stride={:?}, padding={:?}, group={})",
+                    stride, padding, group
+                )
             }
             PolyOp::DeConv {
                 stride,
                 padding,
                 output_padding,
+                group,
             } => {
                 format!(
-                    "DECONV (stride={:?}, padding={:?}, output_padding={:?})",
-                    stride, padding, output_padding
+                    "DECONV (stride={:?}, padding={:?}, output_padding={:?}, group={})",
+                    stride, padding, output_padding, group
                 )
             }
             PolyOp::Concat { axis } => format!("CONCAT (axis={})", axis),
@@ -181,6 +196,9 @@ impl<
         values: &[ValTensor<F>],
     ) -> Result<Option<ValTensor<F>>, CircuitError> {
         Ok(Some(match self {
+            PolyOp::Abs => layouts::abs(config, region, values[..].try_into()?)?,
+            PolyOp::Sign => layouts::sign(config, region, values[..].try_into()?)?,
+            PolyOp::ReLU => layouts::relu(config, region, values[..].try_into()?)?,
             PolyOp::MultiBroadcastTo { shape } => {
                 layouts::expand(config, region, values[..].try_into()?, shape)?
             }
@@ -212,9 +230,18 @@ impl<
             PolyOp::Prod { axes, .. } => {
                 layouts::prod_axes(config, region, values[..].try_into()?, axes)?
             }
-            PolyOp::Conv { padding, stride } => {
-                layouts::conv(config, region, values[..].try_into()?, padding, stride)?
-            }
+            PolyOp::Conv {
+                padding,
+                stride,
+                group,
+            } => layouts::conv(
+                config,
+                region,
+                values[..].try_into()?,
+                padding,
+                stride,
+                *group,
+            )?,
             PolyOp::GatherElements { dim, constant_idx } => {
                 if let Some(idx) = constant_idx {
                     tensor::ops::gather_elements(values[0].get_inner_tensor()?, idx, *dim)?.into()
@@ -261,6 +288,7 @@ impl<
                 padding,
                 output_padding,
                 stride,
+                group,
             } => layouts::deconv(
                 config,
                 region,
@@ -268,6 +296,7 @@ impl<
                 padding,
                 output_padding,
                 stride,
+                *group,
             )?,
             PolyOp::Add => layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Add)?,
             PolyOp::Sub => layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Sub)?,
@@ -347,6 +376,7 @@ impl<
             PolyOp::Reshape(_) | PolyOp::Flatten(_) => in_scales[0],
             PolyOp::Pow(pow) => in_scales[0] * (*pow as crate::Scale),
             PolyOp::Identity { out_scale } => out_scale.unwrap_or(in_scales[0]),
+            PolyOp::Sign { .. } => 0,
             _ => in_scales[0],
         };
         Ok(scale)

src/circuit/ops/region.rs

@@ -1,5 +1,6 @@
 use crate::{
     circuit::table::Range,
+    fieldutils::IntegerRep,
     tensor::{Tensor, TensorType, ValTensor, ValType, VarTensor},
 };
 #[cfg(not(target_arch = "wasm32"))]
@@ -9,7 +10,8 @@ use halo2_proofs::{
     plonk::{Error, Selector},
 };
 use halo2curves::ff::PrimeField;
-use portable_atomic::AtomicI64 as AtomicInt;
+use itertools::Itertools;
+use maybe_rayon::iter::ParallelExtend;
 use std::{
     cell::RefCell,
     collections::{HashMap, HashSet},
@@ -84,6 +86,88 @@ impl ShuffleIndex {
     }
 }
 
+#[derive(Debug, Clone)]
+/// Some settings for a region to differentiate it across the different phases of proof generation
+pub struct RegionSettings {
+    /// whether we are in witness generation mode
+    pub witness_gen: bool,
+    /// whether we should check range checks for validity
+    pub check_range: bool,
+    /// base for decompositions
+    pub base: usize,
+    /// number of legs for decompositions
+    pub legs: usize,
+}
+
+#[allow(unsafe_code)]
+unsafe impl Sync for RegionSettings {}
+#[allow(unsafe_code)]
+unsafe impl Send for RegionSettings {}
+
+impl RegionSettings {
+    /// Create a new region settings
+    pub fn new(witness_gen: bool, check_range: bool, base: usize, legs: usize) -> RegionSettings {
+        RegionSettings {
+            witness_gen,
+            check_range,
+            base,
+            legs,
+        }
+    }
+
+    /// Create a new region settings with all true
+    pub fn all_true(base: usize, legs: usize) -> RegionSettings {
+        RegionSettings {
+            witness_gen: true,
+            check_range: true,
+            base,
+            legs,
+        }
+    }
+
+    /// Create a new region settings with all false
+    pub fn all_false(base: usize, legs: usize) -> RegionSettings {
+        RegionSettings {
+            witness_gen: false,
+            check_range: false,
+            base,
+            legs,
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+/// Region statistics
+pub struct RegionStatistics {
+    /// the current maximum value of the lookup inputs
+    pub max_lookup_inputs: IntegerRep,
+    /// the current minimum value of the lookup inputs
+    pub min_lookup_inputs: IntegerRep,
+    /// the current maximum value of the range size
+    pub max_range_size: IntegerRep,
+    /// the current set of used lookups
+    pub used_lookups: HashSet<LookupOp>,
+    /// the current set of used range checks
+    pub used_range_checks: HashSet<Range>,
+}
+
+impl RegionStatistics {
+    /// update the statistics with another set of statistics
+    pub fn update(&mut self, other: &RegionStatistics) {
+        self.max_lookup_inputs = self.max_lookup_inputs.max(other.max_lookup_inputs);
+        self.min_lookup_inputs = self.min_lookup_inputs.min(other.min_lookup_inputs);
+        self.max_range_size = self.max_range_size.max(other.max_range_size);
+        self.used_lookups.extend(other.used_lookups.clone());
+        self.used_range_checks
+            .extend(other.used_range_checks.clone());
+    }
+}
+
+#[allow(unsafe_code)]
+unsafe impl Sync for RegionStatistics {}
+#[allow(unsafe_code)]
+unsafe impl Send for RegionStatistics {}
+
 #[derive(Debug)]
 /// A context for a region
 pub struct RegionCtx<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
@@ -93,17 +177,22 @@ pub struct RegionCtx<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Ha
     num_inner_cols: usize,
     dynamic_lookup_index: DynamicLookupIndex,
     shuffle_index: ShuffleIndex,
-    used_lookups: HashSet<LookupOp>,
-    used_range_checks: HashSet<Range>,
-    max_lookup_inputs: i64,
-    min_lookup_inputs: i64,
-    max_range_size: i64,
-    witness_gen: bool,
-    check_lookup_range: bool,
+    statistics: RegionStatistics,
+    settings: RegionSettings,
     assigned_constants: ConstantsMap<F>,
 }
 
 impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a, F> {
+    /// get the region's decomposition base
+    pub fn base(&self) -> usize {
+        self.settings.base
+    }
+
+    /// get the region's decomposition legs
+    pub fn legs(&self) -> usize {
+        self.settings.legs
+    }
+
     #[cfg(not(target_arch = "wasm32"))]
     ///
     pub fn debug_report(&self) {
@@ -151,16 +240,27 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
 
     ///
     pub fn witness_gen(&self) -> bool {
-        self.witness_gen
+        self.settings.witness_gen
     }
 
     ///
-    pub fn check_lookup_range(&self) -> bool {
-        self.check_lookup_range
+    pub fn check_range(&self) -> bool {
+        self.settings.check_range
+    }
+
+    ///
+    pub fn statistics(&self) -> &RegionStatistics {
+        &self.statistics
     }
 
     /// Create a new region context
-    pub fn new(region: Region<'a, F>, row: usize, num_inner_cols: usize) -> RegionCtx<'a, F> {
+    pub fn new(
+        region: Region<'a, F>,
+        row: usize,
+        num_inner_cols: usize,
+        decomp_base: usize,
+        decomp_legs: usize,
+    ) -> RegionCtx<'a, F> {
         let region = Some(RefCell::new(region));
         let linear_coord = row * num_inner_cols;
 
@@ -171,13 +271,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             linear_coord,
             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,
-            witness_gen: true,
-            check_lookup_range: true,
+            statistics: RegionStatistics::default(),
+            settings: RegionSettings::all_true(decomp_base, decomp_legs),
             assigned_constants: HashMap::new(),
         }
     }
@@ -187,45 +282,20 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         region: Region<'a, F>,
         row: usize,
         num_inner_cols: usize,
+        decomp_base: usize,
+        decomp_legs: usize,
         constants: ConstantsMap<F>,
     ) -> RegionCtx<'a, F> {
-        let mut new_self = Self::new(region, row, num_inner_cols);
+        let mut new_self = Self::new(region, row, num_inner_cols, decomp_base, decomp_legs);
         new_self.assigned_constants = constants;
         new_self
     }
-    /// Create a new region context from a wrapped region
-    pub fn from_wrapped_region(
-        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 {
-            region,
-            num_inner_cols,
-            linear_coord,
-            row,
-            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,
-            witness_gen: false,
-            check_lookup_range: false,
-            assigned_constants: HashMap::new(),
-        }
-    }
 
     /// Create a new region context
     pub fn new_dummy(
         row: usize,
         num_inner_cols: usize,
-        witness_gen: bool,
-        check_lookup_range: bool,
+        settings: RegionSettings,
     ) -> RegionCtx<'a, F> {
         let region = None;
         let linear_coord = row * num_inner_cols;
@@ -237,13 +307,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             row,
             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,
-            witness_gen,
-            check_lookup_range,
+            statistics: RegionStatistics::default(),
+            settings,
             assigned_constants: HashMap::new(),
         }
     }
@@ -253,8 +318,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         row: usize,
         linear_coord: usize,
         num_inner_cols: usize,
-        witness_gen: bool,
-        check_lookup_range: bool,
+        settings: RegionSettings,
     ) -> RegionCtx<'a, F> {
         let region = None;
         RegionCtx {
@@ -264,13 +328,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             row,
             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,
-            witness_gen,
-            check_lookup_range,
+            statistics: RegionStatistics::default(),
+            settings,
             assigned_constants: HashMap::new(),
         }
     }
@@ -321,12 +380,9 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
     ) -> Result<(), CircuitError> {
         let row = AtomicUsize::new(self.row());
         let linear_coord = AtomicUsize::new(self.linear_coord());
-        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 statistics = Arc::new(Mutex::new(self.statistics.clone()));
         let shuffle_index = Arc::new(Mutex::new(self.shuffle_index.clone()));
+        let dynamic_lookup_index = Arc::new(Mutex::new(self.dynamic_lookup_index.clone()));
         let constants = Arc::new(Mutex::new(self.assigned_constants.clone()));
 
         *output = output.par_enum_map(|idx, _| {
@@ -340,8 +396,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
                 starting_offset,
                 starting_linear_coord,
                 self.num_inner_cols,
-                self.witness_gen,
-                self.check_lookup_range,
+                self.settings.clone(),
             );
             let res = inner_loop_function(idx, &mut local_reg);
             // we update the offset and constants
@@ -351,14 +406,9 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
                 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());
+            let mut statistics = statistics.lock().unwrap();
+            statistics.update(local_reg.statistics());
             // update the dynamic lookup index
             let mut dynamic_lookup_index = dynamic_lookup_index.lock().unwrap();
             dynamic_lookup_index.update(&local_reg.dynamic_lookup_index);
@@ -372,20 +422,11 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             res
         })?;
         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)
+        self.statistics = Arc::try_unwrap(statistics)
             .map_err(|e| CircuitError::GetLookupsError(format!("{:?}", e)))?
             .into_inner()
             .map_err(|e| CircuitError::GetLookupsError(format!("{:?}", e)))?;
-        self.used_range_checks = Arc::try_unwrap(range_checks)
-            .map_err(|e| CircuitError::GetRangeChecksError(format!("{:?}", e)))?
-            .into_inner()
-            .map_err(|e| CircuitError::GetRangeChecksError(format!("{:?}", e)))?;
         self.dynamic_lookup_index = Arc::try_unwrap(dynamic_lookup_index)
             .map_err(|e| CircuitError::GetDynamicLookupError(format!("{:?}", e)))?
             .into_inner()
@@ -409,11 +450,11 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
     ) -> Result<(), CircuitError> {
         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());
+            max = max.max(i.int_evals()?.into_iter().max().unwrap_or_default());
+            min = min.min(i.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);
+        self.statistics.max_lookup_inputs = self.statistics.max_lookup_inputs.max(max);
+        self.statistics.min_lookup_inputs = self.statistics.min_lookup_inputs.min(min);
         Ok(())
     }
 
@@ -425,7 +466,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
 
         let range_size = (range.1 - range.0).abs();
 
-        self.max_range_size = self.max_range_size.max(range_size);
+        self.statistics.max_range_size = self.statistics.max_range_size.max(range_size);
         Ok(())
     }
 
@@ -440,13 +481,13 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         lookup: LookupOp,
         inputs: &[ValTensor<F>],
     ) -> Result<(), CircuitError> {
-        self.used_lookups.insert(lookup);
+        self.statistics.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<(), CircuitError> {
-        self.used_range_checks.insert(range);
+        self.statistics.used_range_checks.insert(range);
         self.update_max_min_lookup_range(range)
     }
 
@@ -487,27 +528,27 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
 
     /// get used lookups
     pub fn used_lookups(&self) -> HashSet<LookupOp> {
-        self.used_lookups.clone()
+        self.statistics.used_lookups.clone()
     }
 
     /// get used range checks
     pub fn used_range_checks(&self) -> HashSet<Range> {
-        self.used_range_checks.clone()
+        self.statistics.used_range_checks.clone()
     }
 
     /// max lookup inputs
-    pub fn max_lookup_inputs(&self) -> i64 {
-        self.max_lookup_inputs
+    pub fn max_lookup_inputs(&self) -> IntegerRep {
+        self.statistics.max_lookup_inputs
     }
 
     /// min lookup inputs
-    pub fn min_lookup_inputs(&self) -> i64 {
-        self.min_lookup_inputs
+    pub fn min_lookup_inputs(&self) -> IntegerRep {
+        self.statistics.min_lookup_inputs
     }
 
     /// max range check
-    pub fn max_range_size(&self) -> i64 {
-        self.max_range_size
+    pub fn max_range_size(&self) -> IntegerRep {
+        self.statistics.max_range_size
     }
 
     /// Assign a valtensor to a vartensor
@@ -515,18 +556,18 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         &mut self,
         var: &VarTensor,
         values: &ValTensor<F>,
-    ) -> Result<ValTensor<F>, Error> {
+    ) -> Result<ValTensor<F>, CircuitError> {
         if let Some(region) = &self.region {
-            var.assign(
+            Ok(var.assign(
                 &mut region.borrow_mut(),
                 self.linear_coord,
                 values,
                 &mut self.assigned_constants,
-            )
+            )?)
         } else {
             if !values.is_instance() {
                 let values_map = values.create_constants_map_iterator();
-                self.assigned_constants.extend(values_map);
+                self.assigned_constants.par_extend(values_map);
             }
             Ok(values.clone())
         }
@@ -542,18 +583,18 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         &mut self,
         var: &VarTensor,
         values: &ValTensor<F>,
-    ) -> Result<ValTensor<F>, Error> {
+    ) -> Result<ValTensor<F>, CircuitError> {
         if let Some(region) = &self.region {
-            var.assign(
+            Ok(var.assign(
                 &mut region.borrow_mut(),
                 self.combined_dynamic_shuffle_coord(),
                 values,
                 &mut self.assigned_constants,
-            )
+            )?)
         } else {
             if !values.is_instance() {
                 let values_map = values.create_constants_map_iterator();
-                self.assigned_constants.extend(values_map);
+                self.assigned_constants.par_extend(values_map);
             }
             Ok(values.clone())
         }
@@ -564,7 +605,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         &mut self,
         var: &VarTensor,
         values: &ValTensor<F>,
-    ) -> Result<ValTensor<F>, Error> {
+    ) -> Result<ValTensor<F>, CircuitError> {
         self.assign_dynamic_lookup(var, values)
     }
 
@@ -573,27 +614,24 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         &mut self,
         var: &VarTensor,
         values: &ValTensor<F>,
-        ommissions: &HashSet<&usize>,
-    ) -> Result<ValTensor<F>, Error> {
+        ommissions: &HashSet<usize>,
+    ) -> Result<ValTensor<F>, CircuitError> {
         if let Some(region) = &self.region {
-            var.assign_with_omissions(
+            Ok(var.assign_with_omissions(
                 &mut region.borrow_mut(),
                 self.linear_coord,
                 values,
                 ommissions,
                 &mut self.assigned_constants,
-            )
+            )?)
         } else {
-            let inner_tensor = values.get_inner_tensor().unwrap();
-            let mut values_map = values.create_constants_map();
+            let mut values_clone = values.clone();
+            let mut indices = ommissions.clone().into_iter().collect_vec();
+            values_clone.remove_indices(&mut indices, false)?;
 
-            for o in ommissions {
-                if let ValType::Constant(value) = inner_tensor.get_flat_index(**o) {
-                    values_map.remove(&value);
-                }
-            }
+            let values_map = values.create_constants_map();
 
-            self.assigned_constants.extend(values_map);
+            self.assigned_constants.par_extend(values_map);
 
             Ok(values.clone())
         }

src/circuit/table.rs

@@ -11,20 +11,33 @@ use maybe_rayon::prelude::{IntoParallelIterator, ParallelIterator};
 
 use crate::{
     circuit::CircuitError,
-    fieldutils::i64_to_felt,
-    tensor::{IntoI64, Tensor, TensorType},
+    fieldutils::{integer_rep_to_felt, IntegerRep},
+    tensor::{Tensor, TensorType},
 };
 
+#[cfg(not(target_arch = "wasm32"))]
+use crate::execute::EZKL_REPO_PATH;
+
 use crate::circuit::lookup::LookupOp;
 
 /// The range of the lookup table.
-pub type Range = (i64, i64);
+pub type Range = (IntegerRep, IntegerRep);
 
 /// The safety factor for the range of the lookup table.
-pub const RANGE_MULTIPLIER: i64 = 2;
+pub const RANGE_MULTIPLIER: IntegerRep = 2;
 /// The safety factor offset for the number of rows in the lookup table.
 pub const RESERVED_BLINDING_ROWS_PAD: usize = 3;
 
+#[cfg(not(target_arch = "wasm32"))]
+lazy_static::lazy_static! {
+    /// an optional directory to read and write the lookup table cache
+    pub static ref LOOKUP_CACHE: String = format!("{}/cache", *EZKL_REPO_PATH);
+}
+
+/// The lookup table cache is disabled on wasm32 target.
+#[cfg(target_arch = "wasm32")]
+pub const LOOKUP_CACHE: &str = "";
+
 #[derive(Debug, Clone)]
 ///
 pub struct SelectorConstructor<F: PrimeField> {
@@ -96,21 +109,22 @@ pub struct Table<F: PrimeField> {
     _marker: PhantomData<F>,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
     /// 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_i64(input) - self.range.0).abs() / (self.col_size as i64);
+        let chunk = (crate::fieldutils::felt_to_integer_rep(input) - self.range.0).abs()
+            / (self.col_size as IntegerRep);
 
-        i64_to_felt(chunk)
+        integer_rep_to_felt(chunk)
     }
 
     /// get first_element of column
     pub fn get_first_element(&self, chunk: usize) -> (F, F) {
-        let chunk = chunk as i64;
+        let chunk = chunk as IntegerRep;
         // we index from 1 to prevent soundness issues
-        let first_element = i64_to_felt(chunk * (self.col_size as i64) + self.range.0);
+        let first_element =
+            integer_rep_to_felt(chunk * (self.col_size as IntegerRep) + self.range.0);
         let op_f = self
             .nonlinearity
             .f(&[Tensor::from(vec![first_element].into_iter())])
@@ -130,12 +144,20 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<
 }
 
 ///
-pub fn num_cols_required(range_len: i64, col_size: usize) -> usize {
+pub fn num_cols_required(range_len: IntegerRep, col_size: usize) -> usize {
     // number of cols needed to store the range
-    (range_len / (col_size as i64)) as usize + 1
+    (range_len / (col_size as IntegerRep)) as usize + 1
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
+    fn name(&self) -> String {
+        format!(
+            "{}_{}_{}",
+            self.nonlinearity.as_path(),
+            self.range.0,
+            self.range.1
+        )
+    }
     /// Configures the table.
     pub fn configure(
         cs: &mut ConstraintSystem<F>,
@@ -202,8 +224,51 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<
         let smallest = self.range.0;
         let largest = self.range.1;
 
-        let inputs: Tensor<F> = Tensor::from(smallest..=largest).map(|x| i64_to_felt(x));
-        let evals = self.nonlinearity.f(&[inputs.clone()])?;
+        let gen_table = || -> Result<(Tensor<F>, Tensor<F>), crate::tensor::TensorError> {
+            let inputs = Tensor::from(smallest..=largest)
+                .par_enum_map(|_, x| Ok::<_, crate::tensor::TensorError>(integer_rep_to_felt(x)))?;
+            let evals = self.nonlinearity.f(&[inputs.clone()])?;
+            Ok((inputs, evals.output))
+        };
+
+        let (inputs, evals) = if !LOOKUP_CACHE.is_empty() {
+            let cache = std::path::Path::new(&*LOOKUP_CACHE);
+            let cache_path = cache.join(self.name());
+            let input_path = cache_path.join("inputs");
+            let output_path = cache_path.join("outputs");
+            if cache_path.exists() {
+                log::info!("Loading lookup table from cache: {:?}", cache_path);
+                let (input_cache, output_cache) =
+                    (Tensor::load(&input_path)?, Tensor::load(&output_path)?);
+                (input_cache, output_cache)
+            } else {
+                log::info!(
+                    "Generating lookup table and saving to cache: {:?}",
+                    cache_path
+                );
+
+                // mkdir -p cache_path
+                std::fs::create_dir_all(&cache_path).map_err(|e| {
+                    CircuitError::TensorError(crate::tensor::TensorError::FileSaveError(
+                        e.to_string(),
+                    ))
+                })?;
+
+                let (inputs, evals) = gen_table()?;
+                inputs.save(&input_path)?;
+                evals.save(&output_path)?;
+
+                (inputs, evals)
+            }
+        } else {
+            log::info!(
+                "Generating lookup table {} without cache",
+                self.nonlinearity.as_path()
+            );
+
+            gen_table()?
+        };
+
         let chunked_inputs = inputs.chunks(self.col_size);
 
         self.is_assigned = true;
@@ -235,7 +300,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<
                                     )?;
                                 }
 
-                                let output = evals.output[row_offset];
+                                let output = evals[row_offset];
 
                                 table.assign_cell(
                                     || format!("nl_o_col row {}", row_offset),
@@ -272,12 +337,17 @@ pub struct RangeCheck<F: PrimeField> {
     _marker: PhantomData<F>,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeCheck<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RangeCheck<F> {
+    /// as path
+    pub fn as_path(&self) -> String {
+        format!("rangecheck_{}_{}", self.range.0, self.range.1)
+    }
+
     /// get first_element of column
     pub fn get_first_element(&self, chunk: usize) -> F {
-        let chunk = chunk as i64;
+        let chunk = chunk as IntegerRep;
         // we index from 1 to prevent soundness issues
-        i64_to_felt(chunk * (self.col_size as i64) + self.range.0)
+        integer_rep_to_felt(chunk * (self.col_size as IntegerRep) + self.range.0)
     }
 
     ///
@@ -293,14 +363,14 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeC
     /// 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_i64(input) - self.range.0).abs() / (self.col_size as i64);
+        let chunk = (crate::fieldutils::felt_to_integer_rep(input) - self.range.0).abs()
+            / (self.col_size as IntegerRep);
 
-        i64_to_felt(chunk)
+        integer_rep_to_felt(chunk)
     }
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeCheck<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RangeCheck<F> {
     /// Configures the table.
     pub fn configure(cs: &mut ConstraintSystem<F>, range: Range, logrows: usize) -> RangeCheck<F> {
         log::debug!("range check range: {:?}", range);
@@ -350,7 +420,32 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeC
         let smallest = self.range.0;
         let largest = self.range.1;
 
-        let inputs: Tensor<F> = Tensor::from(smallest..=largest).map(|x| i64_to_felt(x));
+        let inputs: Tensor<F> = if !LOOKUP_CACHE.is_empty() {
+            let cache = std::path::Path::new(&*LOOKUP_CACHE);
+            let cache_path = cache.join(self.as_path());
+            let input_path = cache_path.join("inputs");
+            if cache_path.exists() {
+                log::info!("Loading range check table from cache: {:?}", cache_path);
+                Tensor::load(&input_path)?
+            } else {
+                log::info!(
+                    "Generating range check table and saving to cache: {:?}",
+                    cache_path
+                );
+
+                // mkdir -p cache_path
+                std::fs::create_dir_all(&cache_path)?;
+
+                let inputs = Tensor::from(smallest..=largest).map(|x| integer_rep_to_felt(x));
+                inputs.save(&input_path)?;
+                inputs
+            }
+        } else {
+            log::info!("Generating range check {} without cache", self.as_path());
+
+            Tensor::from(smallest..=largest).map(|x| integer_rep_to_felt(x))
+        };
+
         let chunked_inputs = inputs.chunks(self.col_size);
 
         self.is_assigned = true;

src/circuit/tests.rs

@@ -8,6 +8,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::Fr as F;
 use halo2curves::ff::{Field, PrimeField};
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 use ops::lookup::LookupOp;
 use ops::region::RegionCtx;
 use rand::rngs::OsRng;
@@ -55,7 +56,7 @@ mod matmul {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -132,7 +133,7 @@ mod matmul_col_overflow_double_col {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS);
+                        let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -206,7 +207,7 @@ mod matmul_col_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -256,7 +257,7 @@ mod matmul_col_ultra_overflow_double_col {
     use super::*;
 
     const K: usize = 4;
-    const LEN: usize = 20;
+    const LEN: usize = 10;
     const NUM_INNER_COLS: usize = 2;
 
     #[derive(Clone)]
@@ -290,7 +291,7 @@ mod matmul_col_ultra_overflow_double_col {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS);
+                        let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -374,7 +375,7 @@ mod matmul_col_ultra_overflow {
     use super::*;
 
     const K: usize = 4;
-    const LEN: usize = 20;
+    const LEN: usize = 10;
 
     #[derive(Clone)]
     struct MatmulCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -407,7 +408,7 @@ mod matmul_col_ultra_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -518,7 +519,7 @@ mod dot {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -595,7 +596,7 @@ mod dot_col_overflow_triple_col {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 3);
+                        let mut region = RegionCtx::new(region, 0, 3, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -668,7 +669,7 @@ mod dot_col_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -741,7 +742,7 @@ mod sum {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -811,7 +812,7 @@ mod sum_col_overflow_double_col {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS);
+                        let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -880,7 +881,7 @@ mod sum_col_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -951,7 +952,7 @@ mod composition {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         let _ = config
                             .layout(
                                 &mut region,
@@ -1042,7 +1043,7 @@ mod conv {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -1050,6 +1051,7 @@ mod conv {
                                 Box::new(PolyOp::Conv {
                                     padding: vec![(1, 1); 2],
                                     stride: vec![2; 2],
+                                    group: 1,
                                 }),
                             )
                             .map_err(|_| Error::Synthesis)
@@ -1158,7 +1160,7 @@ mod conv_col_ultra_overflow {
     use super::*;
 
     const K: usize = 4;
-    const LEN: usize = 28;
+    const LEN: usize = 10;
 
     #[derive(Clone)]
     struct ConvCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -1192,7 +1194,7 @@ mod conv_col_ultra_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -1200,6 +1202,7 @@ mod conv_col_ultra_overflow {
                                 Box::new(PolyOp::Conv {
                                     padding: vec![(1, 1); 2],
                                     stride: vec![2; 2],
+                                    group: 1,
                                 }),
                             )
                             .map_err(|_| Error::Synthesis)
@@ -1295,8 +1298,8 @@ mod conv_relu_col_ultra_overflow {
 
     use super::*;
 
-    const K: usize = 4;
-    const LEN: usize = 28;
+    const K: usize = 8;
+    const LEN: usize = 15;
 
     #[derive(Clone)]
     struct ConvCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -1315,15 +1318,23 @@ mod conv_relu_col_ultra_overflow {
         }
 
         fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
-            let a = VarTensor::new_advice(cs, K, 1, LEN * LEN * LEN);
-            let b = VarTensor::new_advice(cs, K, 1, LEN * LEN * LEN);
-            let output = VarTensor::new_advice(cs, K, 1, LEN * LEN * LEN);
+            let a = VarTensor::new_advice(cs, K, 1, LEN * LEN * LEN * 4);
+            let b = VarTensor::new_advice(cs, K, 1, LEN * LEN * LEN * 4);
+            let output = VarTensor::new_advice(cs, K, 1, LEN * LEN * LEN * 4);
             let mut base_config =
                 Self::Config::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::SAFE);
             // sets up a new relu table
+
             base_config
-                .configure_lookup(cs, &b, &output, &a, (-3, 3), K, &LookupOp::ReLU)
+                .configure_range_check(cs, &a, &b, (-1, 1), K)
                 .unwrap();
+
+            base_config
+                .configure_range_check(cs, &a, &b, (0, 1), K)
+                .unwrap();
+
+            let _constant = VarTensor::constant_cols(cs, K, 8, false);
+
             base_config.clone()
         }
 
@@ -1332,12 +1343,12 @@ mod conv_relu_col_ultra_overflow {
             mut config: Self::Config,
             mut layouter: impl Layouter<F>,
         ) -> Result<(), Error> {
-            config.layout_tables(&mut layouter).unwrap();
+            config.layout_range_checks(&mut layouter).unwrap();
             layouter
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 2, 2);
                         let output = config
                             .layout(
                                 &mut region,
@@ -1345,6 +1356,7 @@ mod conv_relu_col_ultra_overflow {
                                 Box::new(PolyOp::Conv {
                                     padding: vec![(1, 1); 2],
                                     stride: vec![2; 2],
+                                    group: 1,
                                 }),
                             )
                             .map_err(|_| Error::Synthesis);
@@ -1352,7 +1364,7 @@ mod conv_relu_col_ultra_overflow {
                             .layout(
                                 &mut region,
                                 &[output.unwrap().unwrap()],
-                                Box::new(LookupOp::ReLU),
+                                Box::new(PolyOp::ReLU),
                             )
                             .unwrap();
                         Ok(())
@@ -1473,7 +1485,7 @@ mod add_w_shape_casting {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Add))
                             .map_err(|_| Error::Synthesis)
@@ -1540,7 +1552,7 @@ mod add {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Add))
                             .map_err(|_| Error::Synthesis)
@@ -1624,7 +1636,7 @@ mod dynamic_lookup {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         for i in 0..NUM_LOOP {
                             layouts::dynamic_lookup(
                                 &config,
@@ -1766,7 +1778,7 @@ mod shuffle {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         for i in 0..NUM_LOOP {
                             layouts::shuffles(
                                 &config,
@@ -1881,7 +1893,7 @@ mod add_with_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Add))
                             .map_err(|_| Error::Synthesis)
@@ -1983,7 +1995,7 @@ mod add_with_overflow_and_poseidon {
             layouter.assign_region(
                 || "model",
                 |region| {
-                    let mut region = RegionCtx::new(region, 0, 1);
+                    let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                     config
                         .base
                         .layout(&mut region, &inputs, Box::new(PolyOp::Add))
@@ -2089,7 +2101,7 @@ mod sub {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Sub))
                             .map_err(|_| Error::Synthesis)
@@ -2156,7 +2168,7 @@ mod mult {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Mult))
                             .map_err(|_| Error::Synthesis)
@@ -2223,7 +2235,7 @@ mod pow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Pow(5)))
                             .map_err(|_| Error::Synthesis)
@@ -2255,7 +2267,6 @@ mod matmul_relu {
 
     const K: usize = 18;
     const LEN: usize = 32;
-    use crate::circuit::lookup::LookupOp;
 
     #[derive(Clone)]
     struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -2285,11 +2296,17 @@ mod matmul_relu {
 
             let mut base_config =
                 BaseConfig::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::SAFE);
-            // sets up a new relu table
+
             base_config
-                .configure_lookup(cs, &b, &output, &a, (-32768, 32768), K, &LookupOp::ReLU)
+                .configure_range_check(cs, &a, &b, (-1, 1), K)
                 .unwrap();
 
+            base_config
+                .configure_range_check(cs, &a, &b, (0, 1023), K)
+                .unwrap();
+
+            let _constant = VarTensor::constant_cols(cs, K, 8, false);
+
             MyConfig { base_config }
         }
 
@@ -2298,11 +2315,14 @@ mod matmul_relu {
             mut config: Self::Config,
             mut layouter: impl Layouter<F>,
         ) -> Result<(), Error> {
-            config.base_config.layout_tables(&mut layouter).unwrap();
+            config
+                .base_config
+                .layout_range_checks(&mut layouter)
+                .unwrap();
             layouter.assign_region(
                 || "",
                 |region| {
-                    let mut region = RegionCtx::new(region, 0, 1);
+                    let mut region = RegionCtx::new(region, 0, 1, 1024, 2);
                     let op = PolyOp::Einsum {
                         equation: "ij,jk->ik".to_string(),
                     };
@@ -2312,7 +2332,7 @@ mod matmul_relu {
                         .unwrap();
                     let _output = config
                         .base_config
-                        .layout(&mut region, &[output.unwrap()], Box::new(LookupOp::ReLU))
+                        .layout(&mut region, &[output.unwrap()], Box::new(PolyOp::ReLU))
                         .unwrap();
                     Ok(())
                 },
@@ -2351,6 +2371,8 @@ mod relu {
         plonk::{Circuit, ConstraintSystem, Error},
     };
 
+    const K: u32 = 8;
+
     #[derive(Clone)]
     struct ReLUCircuit<F: PrimeField + TensorType + PartialOrd> {
         pub input: ValTensor<F>,
@@ -2367,16 +2389,26 @@ mod relu {
 
         fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
             let advices = (0..3)
-                .map(|_| VarTensor::new_advice(cs, 4, 1, 3))
+                .map(|_| VarTensor::new_advice(cs, 8, 1, 3))
                 .collect::<Vec<_>>();
 
-            let nl = LookupOp::ReLU;
-
-            let mut config = BaseConfig::default();
+            let mut config = BaseConfig::configure(
+                cs,
+                &[advices[0].clone(), advices[1].clone()],
+                &advices[2],
+                CheckMode::SAFE,
+            );
 
             config
-                .configure_lookup(cs, &advices[0], &advices[1], &advices[2], (-6, 6), 4, &nl)
+                .configure_range_check(cs, &advices[0], &advices[1], (-1, 1), K as usize)
                 .unwrap();
+
+            config
+                .configure_range_check(cs, &advices[0], &advices[1], (0, 1), K as usize)
+                .unwrap();
+
+            let _constant = VarTensor::constant_cols(cs, K as usize, 8, false);
+
             config
         }
 
@@ -2385,15 +2417,15 @@ mod relu {
             mut config: Self::Config,
             mut layouter: impl Layouter<F>, // layouter is our 'write buffer' for the circuit
         ) -> Result<(), Error> {
-            config.layout_tables(&mut layouter).unwrap();
+            config.layout_range_checks(&mut layouter).unwrap();
             layouter
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
-                        config
-                            .layout(&mut region, &[self.input.clone()], Box::new(LookupOp::ReLU))
-                            .map_err(|_| Error::Synthesis)
+                        let mut region = RegionCtx::new(region, 0, 1, 2, 2);
+                        Ok(config
+                            .layout(&mut region, &[self.input.clone()], Box::new(PolyOp::ReLU))
+                            .unwrap())
                     },
                 )
                 .unwrap();
@@ -2411,7 +2443,7 @@ mod relu {
             input: ValTensor::from(input),
         };
 
-        let prover = MockProver::run(4_u32, &circuit, vec![]).unwrap();
+        let prover = MockProver::run(K, &circuit, vec![]).unwrap();
         prover.assert_satisfied();
     }
 }
@@ -2450,7 +2482,7 @@ mod lookup_ultra_overflow {
                 .map(|_| VarTensor::new_advice(cs, 4, 1, 3))
                 .collect::<Vec<_>>();
 
-            let nl = LookupOp::ReLU;
+            let nl = LookupOp::LeakyReLU { slope: 0.0.into() };
 
             let mut config = BaseConfig::default();
 
@@ -2478,9 +2510,13 @@ mod lookup_ultra_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
-                            .layout(&mut region, &[self.input.clone()], Box::new(LookupOp::ReLU))
+                            .layout(
+                                &mut region,
+                                &[self.input.clone()],
+                                Box::new(LookupOp::LeakyReLU { slope: 0.0.into() }),
+                            )
                             .map_err(|_| Error::Synthesis)
                     },
                 )

src/circuit/utils.rs

@@ -141,23 +141,23 @@ mod tests {
 
     #[test]
     fn f32_eq() {
-        assert!(F32(std::f32::NAN) == F32(std::f32::NAN));
-        assert!(F32(std::f32::NAN) != F32(5.0));
-        assert!(F32(5.0) != F32(std::f32::NAN));
+        assert!(F32(f32::NAN) == F32(f32::NAN));
+        assert!(F32(f32::NAN) != F32(5.0));
+        assert!(F32(5.0) != F32(f32::NAN));
         assert!(F32(0.0) == F32(-0.0));
     }
 
     #[test]
     fn f32_cmp() {
-        assert!(F32(std::f32::NAN) == F32(std::f32::NAN));
-        assert!(F32(std::f32::NAN) < F32(5.0));
-        assert!(F32(5.0) > F32(std::f32::NAN));
+        assert!(F32(f32::NAN) == F32(f32::NAN));
+        assert!(F32(f32::NAN) < F32(5.0));
+        assert!(F32(5.0) > F32(f32::NAN));
         assert!(F32(0.0) == F32(-0.0));
     }
 
     #[test]
     fn f32_hash() {
         assert!(calculate_hash(&F32(0.0)) == calculate_hash(&F32(-0.0)));
-        assert!(calculate_hash(&F32(std::f32::NAN)) == calculate_hash(&F32(-std::f32::NAN)));
+        assert!(calculate_hash(&F32(f32::NAN)) == calculate_hash(&F32(-f32::NAN)));
     }
 }

src/commands.rs

@@ -81,8 +81,10 @@ pub const DEFAULT_CALIBRATION_FILE: &str = "calibration.json";
 pub const DEFAULT_LOOKUP_SAFETY_MARGIN: &str = "2";
 /// Default Compress selectors
 pub const DEFAULT_DISABLE_SELECTOR_COMPRESSION: &str = "false";
-/// Default render vk separately
-pub const DEFAULT_RENDER_VK_SEPERATELY: &str = "false";
+/// Default render reusable verifier
+pub const DEFAULT_RENDER_REUSABLE: &str = "false";
+/// Default contract deployment type
+pub const DEFAULT_CONTRACT_DEPLOYMENT_TYPE: &str = "verifier";
 /// Default VK sol path
 pub const DEFAULT_VK_SOL: &str = "vk.sol";
 /// Default VK abi path
@@ -181,6 +183,67 @@ impl From<&str> for CalibrationTarget {
     }
 }
 
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, PartialOrd)]
+/// Determines what type of contract (verifier, verifier/reusable, vka) should be deployed
+pub enum ContractType {
+    /// Deploys a verifier contrat tailored to the circuit and not reusable
+    Verifier {
+        /// Whether to deploy a reusable verifier. This can reduce state bloat on-chain since you need only deploy a verifying key artifact (vka) for a given circuit which is significantly smaller than the verifier contract (up to 4 times smaller for large circuits)
+        /// Can also be used as an alternative to aggregation for verifiers that are otherwise too large to fit on-chain. 
+        reusable: bool,
+    },
+    /// Deploys a verifying key artifact that the reusable verifier loads into memory during runtime. Encodes the circuit specific data that was otherwise hardcoded onto the stack.
+    VerifyingKeyArtifact,
+}
+
+impl Default for ContractType {
+    fn default() -> Self {
+        ContractType::Verifier {
+            reusable: false,
+        }
+    }
+}
+
+impl std::fmt::Display for ContractType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                ContractType::Verifier { reusable: true } => {
+                    "verifier/reusable".to_string()
+                },
+                ContractType::Verifier {
+                    reusable: false,
+                } => "verifier".to_string(),
+                ContractType::VerifyingKeyArtifact => "vka".to_string(),
+            }
+        )
+    }
+}
+
+impl ToFlags for ContractType {
+    fn to_flags(&self) -> Vec<String> {
+        vec![format!("{}", self)]
+    }
+}
+
+impl From<&str> for ContractType {
+    fn from(s: &str) -> Self {
+        match s {
+            "verifier" => ContractType::Verifier { reusable: false },
+            "verifier/reusable" => ContractType::Verifier { reusable: true },
+            "vka" => ContractType::VerifyingKeyArtifact,
+            _ => {
+                log::error!("Invalid value for ContractType");
+                log::warn!("Defaulting to verifier");
+                ContractType::default()
+            }
+        }
+    }
+}
+
+
 #[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
@@ -243,6 +306,39 @@ impl<'source> FromPyObject<'source> for CalibrationTarget {
         }
     }
 }
+
+#[cfg(feature = "python-bindings")]
+/// Converts ContractType into a PyObject (Required for ContractType to be compatible with Python)
+impl IntoPy<PyObject> for ContractType {
+    fn into_py(self, py: Python) -> PyObject {
+        match self {
+            ContractType::Verifier { reusable: true } => {
+                "verifier/reusable".to_object(py)
+            }
+            ContractType::Verifier {
+                reusable: false,
+            } => "verifier".to_object(py),
+            ContractType::VerifyingKeyArtifact => "vka".to_object(py),
+        }
+    }
+}
+
+#[cfg(feature = "python-bindings")]
+/// Obtains ContractType from PyObject (Required for ContractType to be compatible with Python)
+impl<'source> FromPyObject<'source> for ContractType {
+    fn extract(ob: &'source PyAny) -> PyResult<Self> {
+        let trystr = <PyString as PyTryFrom>::try_from(ob)?;
+        let strval = trystr.to_string();
+        match strval.to_lowercase().as_str() {
+            "verifier" => Ok(ContractType::Verifier {
+                reusable: false,
+            }),
+            "verifier/reusable" => Ok(ContractType::Verifier { reusable: true }),
+            "vka" => Ok(ContractType::VerifyingKeyArtifact),
+            _ => Err(PyValueError::new_err("Invalid value for ContractType")),
+        }
+    }
+}
 // not wasm
 use lazy_static::lazy_static;
 
@@ -666,16 +762,14 @@ pub enum Commands {
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VERIFIER_ABI, value_hint = clap::ValueHint::FilePath)]
         abi_path: Option<PathBuf>,
-        /// Whether the verifier key should be rendered as a separate contract.
-        /// We recommend disabling selector compression if this is enabled.
-        /// To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command.        
-        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY, action = clap::ArgAction::SetTrue)]
-        render_vk_seperately: Option<bool>,
+        /// Whether the to render the verifier as reusable or not. If true, you will need to deploy a VK artifact, passing it as part of the calldata to the verifier.       
+        #[arg(long, default_value = DEFAULT_RENDER_REUSABLE, action = clap::ArgAction::SetTrue)]
+        reusable: Option<bool>,
     },
     #[cfg(not(target_arch = "wasm32"))]
-    /// Creates an Evm verifier for a single proof
-    #[command(name = "create-evm-vk")]
-    CreateEvmVK {
+    /// Creates an Evm verifier artifact for a single proof to be used by the reusable verifier
+    #[command(name = "create-evm-vka")]
+    CreateEvmVKArtifact {
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
@@ -739,11 +833,9 @@ pub enum Commands {
         // logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS, value_hint = clap::ValueHint::Other)]
         logrows: Option<u32>,
-        /// Whether the verifier key should be rendered as a separate contract.
-        /// We recommend disabling selector compression if this is enabled.
-        /// To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command.        
-        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY, action = clap::ArgAction::SetTrue)]
-        render_vk_seperately: Option<bool>,
+        /// Whether the to render the verifier as reusable or not. If true, you will need to deploy a VK artifact, passing it as part of the calldata to the verifier.              
+        #[arg(long, default_value = DEFAULT_RENDER_REUSABLE, action = clap::ArgAction::SetTrue)]
+        reusable: Option<bool>,
     },
     /// Verifies a proof, returning accept or reject
     Verify {
@@ -785,8 +877,8 @@ pub enum Commands {
         commitment: Option<Commitments>,
     },
     #[cfg(not(target_arch = "wasm32"))]
-    /// Deploys an evm verifier that is generated by ezkl
-    DeployEvmVerifier {
+    /// Deploys an evm contract (verifier, reusable verifier, or vk artifact) that is generated by ezkl
+    DeployEvm {
         /// The path to the Solidity code (generated using the create-evm-verifier command)
         #[arg(long, default_value = DEFAULT_SOL_CODE, value_hint = clap::ValueHint::FilePath)]
         sol_code_path: Option<PathBuf>,
@@ -802,25 +894,9 @@ pub enum Commands {
         /// Private secp256K1 key in hex format, 64 chars, no 0x prefix, of the account signing transactions. If None the private key will be generated by Anvil
         #[arg(short = 'P', long, value_hint = clap::ValueHint::Other)]
         private_key: Option<String>,
-    },
-    #[cfg(not(target_arch = "wasm32"))]
-    /// Deploys an evm verifier that is generated by ezkl
-    DeployEvmVK {
-        /// The path to the Solidity code (generated using the create-evm-verifier command)
-        #[arg(long, default_value = DEFAULT_VK_SOL, value_hint = clap::ValueHint::FilePath)]
-        sol_code_path: Option<PathBuf>,
-        /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
-        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
-        rpc_url: Option<String>,
-        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_VK, value_hint = clap::ValueHint::Other)]
-        /// The path to output the contract address
-        addr_path: Option<PathBuf>,
-        /// The optimizer runs to set on the verifier. Lower values optimize for deployment cost, while higher values optimize for gas cost.
-        #[arg(long, default_value = DEFAULT_OPTIMIZER_RUNS, value_hint = clap::ValueHint::Other)]
-        optimizer_runs: usize,
-        /// Private secp256K1 key in hex format, 64 chars, no 0x prefix, of the account signing transactions. If None the private key will be generated by Anvil
-        #[arg(short = 'P', long, value_hint = clap::ValueHint::Other)]
-        private_key: Option<String>,
+        /// Contract type to be deployed
+        #[arg(long = "contract-type", short = 'C', default_value = DEFAULT_CONTRACT_DEPLOYMENT_TYPE, value_hint = clap::ValueHint::Other)]
+        contract: ContractType,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Deploys an evm verifier that allows for data attestation

src/eth.rs

@@ -731,7 +731,7 @@ pub async fn verify_proof_with_data_attestation(
 
     for val in flattened_instances.clone() {
         let bytes = val.to_repr();
-        let u = U256::from_le_slice(bytes.as_slice());
+        let u = U256::from_le_slice(bytes.inner().as_slice());
         public_inputs.push(u);
     }
 

src/execute.rs

@@ -1,3 +1,4 @@
+use crate::circuit::region::RegionSettings;
 use crate::circuit::CheckMode;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::commands::CalibrationTarget;
@@ -194,7 +195,7 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             settings_path,
             sol_code_path,
             abi_path,
-            render_vk_seperately,
+            reusable,
         } => {
             create_evm_verifier(
                 vk_path.unwrap_or(DEFAULT_VK.into()),
@@ -202,7 +203,7 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
                 settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
                 sol_code_path.unwrap_or(DEFAULT_SOL_CODE.into()),
                 abi_path.unwrap_or(DEFAULT_VERIFIER_ABI.into()),
-                render_vk_seperately.unwrap_or(DEFAULT_RENDER_VK_SEPERATELY.parse().unwrap()),
+                reusable.unwrap_or(DEFAULT_RENDER_REUSABLE.parse().unwrap()),
             )
             .await
         }
@@ -218,14 +219,14 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
 
-        Commands::CreateEvmVK {
+        Commands::CreateEvmVKArtifact {
             vk_path,
             srs_path,
             settings_path,
             sol_code_path,
             abi_path,
         } => {
-            create_evm_vk(
+            create_evm_vka(
                 vk_path.unwrap_or(DEFAULT_VK.into()),
                 srs_path,
                 settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
@@ -259,7 +260,7 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             abi_path,
             aggregation_settings,
             logrows,
-            render_vk_seperately,
+            reusable,
         } => {
             create_evm_aggregate_verifier(
                 vk_path.unwrap_or(DEFAULT_VK.into()),
@@ -268,7 +269,7 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
                 abi_path.unwrap_or(DEFAULT_VERIFIER_AGGREGATED_ABI.into()),
                 aggregation_settings,
                 logrows.unwrap_or(DEFAULT_AGGREGATED_LOGROWS.parse().unwrap()),
-                render_vk_seperately.unwrap_or(DEFAULT_RENDER_VK_SEPERATELY.parse().unwrap()),
+                reusable.unwrap_or(DEFAULT_RENDER_REUSABLE.parse().unwrap()),
             )
             .await
         }
@@ -433,12 +434,13 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
         #[cfg(not(target_arch = "wasm32"))]
-        Commands::DeployEvmVerifier {
+        Commands::DeployEvm {
             sol_code_path,
             rpc_url,
             addr_path,
             optimizer_runs,
             private_key,
+            contract,
         } => {
             deploy_evm(
                 sol_code_path.unwrap_or(DEFAULT_SOL_CODE.into()),
@@ -446,25 +448,7 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
                 addr_path.unwrap_or(DEFAULT_CONTRACT_ADDRESS.into()),
                 optimizer_runs,
                 private_key,
-                "Halo2Verifier",
-            )
-            .await
-        }
-        #[cfg(not(target_arch = "wasm32"))]
-        Commands::DeployEvmVK {
-            sol_code_path,
-            rpc_url,
-            addr_path,
-            optimizer_runs,
-            private_key,
-        } => {
-            deploy_evm(
-                sol_code_path.unwrap_or(DEFAULT_VK_SOL.into()),
-                rpc_url,
-                addr_path.unwrap_or(DEFAULT_CONTRACT_ADDRESS_VK.into()),
-                optimizer_runs,
-                private_key,
-                "Halo2VerifyingKey",
+                contract,
             )
             .await
         }
@@ -785,6 +769,9 @@ pub(crate) async fn gen_witness(
 
     let commitment: Commitments = settings.run_args.commitment.into();
 
+    let region_settings =
+        RegionSettings::all_true(settings.run_args.decomp_base, settings.run_args.decomp_legs);
+
     let start_time = Instant::now();
     let witness = if settings.module_requires_polycommit() {
         if get_srs_path(settings.run_args.logrows, srs_path.clone(), commitment).exists() {
@@ -799,8 +786,7 @@ pub(crate) async fn gen_witness(
                         &mut input,
                         vk.as_ref(),
                         Some(&srs),
-                        true,
-                        true,
+                        region_settings,
                     )?
                 }
                 Commitments::IPA => {
@@ -814,8 +800,7 @@ pub(crate) async fn gen_witness(
                         &mut input,
                         vk.as_ref(),
                         Some(&srs),
-                        true,
-                        true,
+                        region_settings,
                     )?
                 }
             }
@@ -825,12 +810,16 @@ pub(crate) async fn gen_witness(
                 &mut input,
                 vk.as_ref(),
                 None,
-                true,
-                true,
+                region_settings,
             )?
         }
     } else {
-        circuit.forward::<KZGCommitmentScheme<Bn256>>(&mut input, vk.as_ref(), None, true, true)?
+        circuit.forward::<KZGCommitmentScheme<Bn256>>(
+            &mut input,
+            vk.as_ref(),
+            None,
+            region_settings,
+        )?
     };
 
     // print each variable tuple (symbol, value) as symbol=value
@@ -1023,6 +1012,8 @@ pub(crate) async fn calibrate(
     use std::collections::HashMap;
     use tabled::Table;
 
+    use crate::fieldutils::IntegerRep;
+
     let data = GraphData::from_path(data)?;
     // load the pre-generated settings
     let settings = GraphSettings::load(&settings_path)?;
@@ -1131,7 +1122,7 @@ pub(crate) async fn calibrate(
             param_scale,
             scale_rebase_multiplier,
             div_rebasing,
-            lookup_range: (i64::MIN, i64::MAX),
+            lookup_range: (IntegerRep::MIN, IntegerRep::MAX),
             ..settings.run_args.clone()
         };
 
@@ -1171,8 +1162,10 @@ pub(crate) async fn calibrate(
                         &mut data.clone(),
                         None,
                         None,
-                        true,
-                        false,
+                        RegionSettings::all_true(
+                            settings.run_args.decomp_base,
+                            settings.run_args.decomp_legs,
+                        ),
                     )
                     .map_err(|e| format!("failed to forward: {}", e))?;
 
@@ -1366,8 +1359,10 @@ pub(crate) async fn calibrate(
         let module_log_row = best_params.module_constraint_logrows_with_blinding();
         let instance_logrows = best_params.log2_total_instances_with_blinding();
         let dynamic_lookup_logrows = best_params.dynamic_lookup_and_shuffle_logrows_with_blinding();
+        let range_check_logrows = best_params.range_check_log_rows_with_blinding();
 
         let mut reduction = std::cmp::max(lookup_log_rows, module_log_row);
+        reduction = std::cmp::max(reduction, range_check_logrows);
         reduction = std::cmp::max(reduction, instance_logrows);
         reduction = std::cmp::max(reduction, dynamic_lookup_logrows);
         reduction = std::cmp::max(reduction, crate::graph::MIN_LOGROWS);
@@ -1420,7 +1415,7 @@ pub(crate) async fn create_evm_verifier(
     settings_path: PathBuf,
     sol_code_path: PathBuf,
     abi_path: PathBuf,
-    render_vk_seperately: bool,
+    reusable: bool,
 ) -> Result<String, EZKLError> {
     let settings = GraphSettings::load(&settings_path)?;
     let commitment: Commitments = settings.run_args.commitment.into();
@@ -1442,16 +1437,16 @@ pub(crate) async fn create_evm_verifier(
         halo2_solidity_verifier::BatchOpenScheme::Bdfg21,
         num_instance,
     );
-    let verifier_solidity = if render_vk_seperately {
-        generator.render_separately()?.0 // ignore the rendered vk for now and generate it in create_evm_vk
+    let (verifier_solidity, name) = if reusable {
+        (generator.render_separately()?.0, "Halo2VerifierReusable") // ignore the rendered vk artifact for now and generate it in create_evm_vka
     } else {
-        generator.render()?
+        (generator.render()?, "Halo2Verifier")
     };
 
     File::create(sol_code_path.clone())?.write_all(verifier_solidity.as_bytes())?;
 
     // fetch abi of the contract
-    let (abi, _, _) = get_contract_artifacts(sol_code_path, "Halo2Verifier", 0).await?;
+    let (abi, _, _) = get_contract_artifacts(sol_code_path, name, 0).await?;
     // save abi to file
     serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
 
@@ -1459,7 +1454,7 @@ pub(crate) async fn create_evm_verifier(
 }
 
 #[cfg(not(target_arch = "wasm32"))]
-pub(crate) async fn create_evm_vk(
+pub(crate) async fn create_evm_vka(
     vk_path: PathBuf,
     srs_path: Option<PathBuf>,
     settings_path: PathBuf,
@@ -1492,7 +1487,7 @@ pub(crate) async fn create_evm_vk(
     File::create(sol_code_path.clone())?.write_all(vk_solidity.as_bytes())?;
 
     // fetch abi of the contract
-    let (abi, _, _) = get_contract_artifacts(sol_code_path, "Halo2VerifyingKey", 0).await?;
+    let (abi, _, _) = get_contract_artifacts(sol_code_path, "Halo2VerifyingArtifact", 0).await?;
     // save abi to file
     serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
 
@@ -1502,10 +1497,10 @@ pub(crate) async fn create_evm_vk(
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn create_evm_data_attestation(
     settings_path: PathBuf,
-    _sol_code_path: PathBuf,
-    _abi_path: PathBuf,
-    _input: PathBuf,
-    _witness: Option<PathBuf>,
+    sol_code_path: PathBuf,
+    abi_path: PathBuf,
+    input: PathBuf,
+    witness: Option<PathBuf>,
 ) -> Result<String, EZKLError> {
     #[allow(unused_imports)]
     use crate::graph::{DataSource, VarVisibility};
@@ -1517,7 +1512,7 @@ pub(crate) async fn create_evm_data_attestation(
     trace!("params computed");
 
     // if input is not provided, we just instantiate dummy input data
-    let data = GraphData::from_path(_input).unwrap_or(GraphData::new(DataSource::File(vec![])));
+    let data = GraphData::from_path(input).unwrap_or(GraphData::new(DataSource::File(vec![])));
 
     let output_data = if let Some(DataSource::OnChain(source)) = data.output_data {
         if visibility.output.is_private() {
@@ -1552,7 +1547,7 @@ pub(crate) async fn create_evm_data_attestation(
         || settings.run_args.output_visibility == Visibility::KZGCommit
         || settings.run_args.param_visibility == Visibility::KZGCommit
     {
-        let witness = GraphWitness::from_path(_witness.unwrap_or(DEFAULT_WITNESS.into()))?;
+        let witness = GraphWitness::from_path(witness.unwrap_or(DEFAULT_WITNESS.into()))?;
         let commitments = witness.get_polycommitments();
         let proof_first_bytes = get_proof_commitments::<
             KZGCommitmentScheme<Bn256>,
@@ -1566,12 +1561,12 @@ pub(crate) async fn create_evm_data_attestation(
     };
 
     let output = fix_da_sol(input_data, output_data, commitment_bytes)?;
-    let mut f = File::create(_sol_code_path.clone())?;
+    let mut f = File::create(sol_code_path.clone())?;
     let _ = f.write(output.as_bytes());
     // fetch abi of the contract
-    let (abi, _, _) = get_contract_artifacts(_sol_code_path, "DataAttestation", 0).await?;
+    let (abi, _, _) = get_contract_artifacts(sol_code_path, "DataAttestation", 0).await?;
     // save abi to file
-    serde_json::to_writer(std::fs::File::create(_abi_path)?, &abi)?;
+    serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
 
     Ok(String::new())
 }
@@ -1610,8 +1605,13 @@ pub(crate) async fn deploy_evm(
     addr_path: PathBuf,
     runs: usize,
     private_key: Option<String>,
-    contract_name: &str,
+    contract: ContractType,
 ) -> Result<String, EZKLError> {
+    let contract_name = match contract {
+        ContractType::Verifier { reusable: false } => "Halo2Verifier",
+        ContractType::Verifier { reusable: true } => "Halo2VerifierReusable",
+        ContractType::VerifyingKeyArtifact => "Halo2VerifyingArtifact",
+    };
     let contract_address = deploy_contract_via_solidity(
         sol_code_path,
         rpc_url.as_deref(),
@@ -1702,7 +1702,7 @@ pub(crate) async fn create_evm_aggregate_verifier(
     abi_path: PathBuf,
     circuit_settings: Vec<PathBuf>,
     logrows: u32,
-    render_vk_seperately: bool,
+    reusable: bool,
 ) -> Result<String, EZKLError> {
     let srs_path = get_srs_path(logrows, srs_path, Commitments::KZG);
     let params: ParamsKZG<Bn256> = load_srs_verifier::<KZGCommitmentScheme<Bn256>>(srs_path)?;
@@ -1740,8 +1740,8 @@ pub(crate) async fn create_evm_aggregate_verifier(
 
     generator = generator.set_acc_encoding(Some(acc_encoding));
 
-    let verifier_solidity = if render_vk_seperately {
-        generator.render_separately()?.0 // ignore the rendered vk for now and generate it in create_evm_vk
+    let verifier_solidity = if reusable {
+        generator.render_separately()?.0 // ignore the rendered vk artifact for now and generate it in create_evm_vka
     } else {
         generator.render()?
     };

src/fieldutils.rs

@@ -2,42 +2,21 @@ use halo2_proofs::arithmetic::Field;
 /// Utilities for converting from Halo2 PrimeField types to integers (and vice-versa).
 use halo2curves::ff::PrimeField;
 
-/// Converts an i32 to a PrimeField element.
-pub fn i32_to_felt<F: PrimeField>(x: i32) -> F {
-    if x >= 0 {
-        F::from(x as u64)
-    } else {
-        -F::from(x.unsigned_abs() as u64)
-    }
-}
+/// Integer representation of a PrimeField element.
+pub type IntegerRep = i128;
 
 /// Converts an i64 to a PrimeField element.
-pub fn i64_to_felt<F: PrimeField>(x: i64) -> F {
+pub fn integer_rep_to_felt<F: PrimeField>(x: IntegerRep) -> F {
     if x >= 0 {
         F::from_u128(x as u128)
     } else {
-        -F::from_u128((-x) as u128)
-    }
-}
-
-/// Converts a PrimeField element to an i32.
-pub fn felt_to_i32<F: PrimeField + PartialOrd + Field>(x: F) -> i32 {
-    if x > F::from(i32::MAX as u64) {
-        let rep = (-x).to_repr();
-        let negtmp: &[u8] = rep.as_ref();
-        let lower_32 = u32::from_le_bytes(negtmp[..4].try_into().unwrap());
-        -(lower_32 as i32)
-    } else {
-        let rep = (x).to_repr();
-        let tmp: &[u8] = rep.as_ref();
-        let lower_32 = u32::from_le_bytes(tmp[..4].try_into().unwrap());
-        lower_32 as i32
+        -F::from_u128(x.saturating_neg() as u128)
     }
 }
 
 /// Converts a PrimeField element to an f64.
 pub fn felt_to_f64<F: PrimeField + PartialOrd + Field>(x: F) -> f64 {
-    if x > F::from_u128(i64::MAX as u128) {
+    if x > F::from_u128(IntegerRep::MAX as u128) {
         let rep = (-x).to_repr();
         let negtmp: &[u8] = rep.as_ref();
         let lower_128: u128 = u128::from_le_bytes(negtmp[..16].try_into().unwrap());
@@ -51,17 +30,17 @@ pub fn felt_to_f64<F: PrimeField + PartialOrd + Field>(x: F) -> f64 {
 }
 
 /// Converts a PrimeField element to an i64.
-pub fn felt_to_i64<F: PrimeField + PartialOrd + Field>(x: F) -> i64 {
-    if x > F::from_u128(i64::MAX as u128) {
+pub fn felt_to_integer_rep<F: PrimeField + PartialOrd + Field>(x: F) -> IntegerRep {
+    if x > F::from_u128(IntegerRep::MAX as u128) {
         let rep = (-x).to_repr();
         let negtmp: &[u8] = rep.as_ref();
         let lower_128: u128 = u128::from_le_bytes(negtmp[..16].try_into().unwrap());
-        -(lower_128 as i64)
+        -(lower_128 as IntegerRep)
     } else {
         let rep = (x).to_repr();
         let tmp: &[u8] = rep.as_ref();
         let lower_128: u128 = u128::from_le_bytes(tmp[..16].try_into().unwrap());
-        lower_128 as i64
+        lower_128 as IntegerRep
     }
 }
 
@@ -73,33 +52,24 @@ mod test {
 
     #[test]
     fn test_conv() {
-        let res: F = i32_to_felt(-15i32);
+        let res: F = integer_rep_to_felt(-15);
         assert_eq!(res, -F::from(15));
 
-        let res: F = i32_to_felt(2_i32.pow(17));
+        let res: F = integer_rep_to_felt(2_i128.pow(17));
         assert_eq!(res, F::from(131072));
 
-        let res: F = i64_to_felt(-15i64);
+        let res: F = integer_rep_to_felt(-15);
         assert_eq!(res, -F::from(15));
 
-        let res: F = i64_to_felt(2_i64.pow(17));
+        let res: F = integer_rep_to_felt(2_i128.pow(17));
         assert_eq!(res, F::from(131072));
     }
 
     #[test]
-    fn felttoi32() {
-        for x in -(2i32.pow(16))..(2i32.pow(16)) {
-            let fieldx: F = i32_to_felt::<F>(x);
-            let xf: i32 = felt_to_i32::<F>(fieldx);
-            assert_eq!(x, xf);
-        }
-    }
-
-    #[test]
-    fn felttoi64() {
-        for x in -(2i64.pow(20))..(2i64.pow(20)) {
-            let fieldx: F = i64_to_felt::<F>(x);
-            let xf: i64 = felt_to_i64::<F>(fieldx);
+    fn felttointegerrep() {
+        for x in -(2_i128.pow(16))..(2_i128.pow(16)) {
+            let fieldx: F = integer_rep_to_felt::<F>(x);
+            let xf: i128 = felt_to_integer_rep::<F>(fieldx);
             assert_eq!(x, xf);
         }
     }

src/graph/errors.rs

@@ -50,7 +50,7 @@ pub enum GraphError {
     /// Tract error
     #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
     #[error("[tract] {0}")]
-    TractError(#[from] tract_onnx::tract_core::anyhow::Error),
+    TractError(#[from] tract_onnx::prelude::TractError),
     /// Packing exponent is too large
     #[error("largest packing exponent exceeds max. try reducing the scale")]
     PackingExponent,

src/graph/input.rs

@@ -1,7 +1,7 @@
 use super::errors::GraphError;
 use super::quantize_float;
 use crate::circuit::InputType;
-use crate::fieldutils::i64_to_felt;
+use crate::fieldutils::integer_rep_to_felt;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::graph::postgres::Client;
 #[cfg(not(target_arch = "wasm32"))]
@@ -128,7 +128,7 @@ impl FileSourceInner {
     /// Convert to a field element
     pub fn to_field(&self, scale: crate::Scale) -> Fp {
         match self {
-            FileSourceInner::Float(f) => i64_to_felt(quantize_float(f, 0.0, scale).unwrap()),
+            FileSourceInner::Float(f) => integer_rep_to_felt(quantize_float(f, 0.0, scale).unwrap()),
             FileSourceInner::Bool(f) => {
                 if *f {
                     Fp::one()
@@ -150,7 +150,7 @@ impl FileSourceInner {
                     0.0
                 }
             }
-            FileSourceInner::Field(f) => crate::fieldutils::felt_to_i64(*f) as f64,
+            FileSourceInner::Field(f) => crate::fieldutils::felt_to_integer_rep(*f) as f64,
         }
     }
 }

src/graph/mod.rs

@@ -34,10 +34,10 @@ use self::input::{FileSource, GraphData};
 use self::modules::{GraphModules, ModuleConfigs, ModuleForwardResult, ModuleSizes};
 use crate::circuit::lookup::LookupOp;
 use crate::circuit::modules::ModulePlanner;
-use crate::circuit::region::ConstantsMap;
+use crate::circuit::region::{ConstantsMap, RegionSettings};
 use crate::circuit::table::{num_cols_required, Range, Table, RESERVED_BLINDING_ROWS_PAD};
 use crate::circuit::{CheckMode, InputType};
-use crate::fieldutils::felt_to_f64;
+use crate::fieldutils::{felt_to_f64, IntegerRep};
 use crate::pfsys::PrettyElements;
 use crate::tensor::{Tensor, ValTensor};
 use crate::{RunArgs, EZKL_BUF_CAPACITY};
@@ -69,13 +69,14 @@ pub use vars::*;
 use crate::pfsys::field_to_string;
 
 /// The safety factor for the range of the lookup table.
-pub const RANGE_MULTIPLIER: i64 = 2;
+pub const RANGE_MULTIPLIER: IntegerRep = 2;
 
 /// The maximum number of columns in a lookup table.
 pub const MAX_NUM_LOOKUP_COLS: usize = 12;
 
 /// Max representation of a lookup table input
-pub const MAX_LOOKUP_ABS: i64 = (MAX_NUM_LOOKUP_COLS as i64) * 2_i64.pow(MAX_PUBLIC_SRS);
+pub const MAX_LOOKUP_ABS: IntegerRep =
+    (MAX_NUM_LOOKUP_COLS as IntegerRep) * 2_i128.pow(MAX_PUBLIC_SRS);
 
 #[cfg(not(target_arch = "wasm32"))]
 lazy_static! {
@@ -126,11 +127,11 @@ pub struct GraphWitness {
     /// Any hashes of outputs generated during the forward pass
     pub processed_outputs: Option<ModuleForwardResult>,
     /// max lookup input
-    pub max_lookup_inputs: i64,
+    pub max_lookup_inputs: IntegerRep,
     /// max lookup input
-    pub min_lookup_inputs: i64,
+    pub min_lookup_inputs: IntegerRep,
     /// max range check size
-    pub max_range_size: i64,
+    pub max_range_size: IntegerRep,
 }
 
 impl GraphWitness {
@@ -450,6 +451,18 @@ impl GraphSettings {
             .ceil() as u32
     }
 
+    /// Calc the number of rows required for the range checks
+    pub fn range_check_log_rows_with_blinding(&self) -> u32 {
+        let max_range = self
+            .required_range_checks
+            .iter()
+            .map(|x| x.1 - x.0)
+            .max()
+            .unwrap_or(0);
+
+        (max_range as f32).log2().ceil() as u32
+    }
+
     fn model_constraint_logrows_with_blinding(&self) -> u32 {
         (self.num_rows as f64 + RESERVED_BLINDING_ROWS as f64)
             .log2()
@@ -804,18 +817,26 @@ impl GraphCircuit {
         // the ordering here is important, we want the inputs to come before the outputs
         // as they are configured in that order as Column<Instances>
         let mut public_inputs: Vec<Fp> = vec![];
-        if self.settings().run_args.input_visibility.is_public() {
-            public_inputs.extend(self.graph_witness.inputs.clone().into_iter().flatten())
-        } else if let Some(processed_inputs) = &data.processed_inputs {
+
+        // we first process the inputs
+        if let Some(processed_inputs) = &data.processed_inputs {
             public_inputs.extend(processed_inputs.get_instances().into_iter().flatten());
         }
 
+        // we then process the params
         if let Some(processed_params) = &data.processed_params {
             public_inputs.extend(processed_params.get_instances().into_iter().flatten());
         }
 
+        // if the inputs are public, we add them to the public inputs AFTER the processed params as they are configured in that order as Column<Instances>
+        if self.settings().run_args.input_visibility.is_public() {
+            public_inputs.extend(self.graph_witness.inputs.clone().into_iter().flatten())
+        }
+
+        // if the outputs are public, we add them to the public inputs
         if self.settings().run_args.output_visibility.is_public() {
             public_inputs.extend(self.graph_witness.outputs.clone().into_iter().flatten());
+        // if the outputs are processed, we add the processed outputs to the public inputs
         } else if let Some(processed_outputs) = &data.processed_outputs {
             public_inputs.extend(processed_outputs.get_instances().into_iter().flatten());
         }
@@ -1036,12 +1057,12 @@ impl GraphCircuit {
 
     fn calc_safe_lookup_range(min_max_lookup: Range, lookup_safety_margin: f64) -> Range {
         (
-            (lookup_safety_margin * min_max_lookup.0 as f64).floor() as i64,
-            (lookup_safety_margin * min_max_lookup.1 as f64).ceil() as i64,
+            (lookup_safety_margin * min_max_lookup.0 as f64).floor() as IntegerRep,
+            (lookup_safety_margin * min_max_lookup.1 as f64).ceil() as IntegerRep,
         )
     }
 
-    fn calc_num_cols(range_len: i64, max_logrows: u32) -> usize {
+    fn calc_num_cols(range_len: IntegerRep, max_logrows: u32) -> usize {
         let max_col_size = Table::<Fp>::cal_col_size(max_logrows as usize, RESERVED_BLINDING_ROWS);
         num_cols_required(range_len, max_col_size)
     }
@@ -1049,7 +1070,7 @@ impl GraphCircuit {
     fn table_size_logrows(
         &self,
         safe_lookup_range: Range,
-        max_range_size: i64,
+        max_range_size: IntegerRep,
     ) -> Result<u32, GraphError> {
         // pick the range with the largest absolute size safe_lookup_range or max_range_size
         let safe_range = std::cmp::max(
@@ -1068,7 +1089,7 @@ impl GraphCircuit {
     pub fn calc_min_logrows(
         &mut self,
         min_max_lookup: Range,
-        max_range_size: i64,
+        max_range_size: IntegerRep,
         max_logrows: Option<u32>,
         lookup_safety_margin: f64,
     ) -> Result<(), GraphError> {
@@ -1086,7 +1107,7 @@ impl GraphCircuit {
             (safe_lookup_range.1.saturating_sub(safe_lookup_range.0)).saturating_abs();
         // check if has overflowed max lookup input
 
-        if lookup_size > (MAX_LOOKUP_ABS as f64 / lookup_safety_margin).floor() as i64 {
+        if lookup_size > (MAX_LOOKUP_ABS as f64 / lookup_safety_margin).floor() as IntegerRep {
             return Err(GraphError::LookupRangeTooLarge(
                 lookup_size.unsigned_abs() as usize
             ));
@@ -1166,7 +1187,7 @@ impl GraphCircuit {
         &self,
         k: u32,
         safe_lookup_range: Range,
-        max_range_size: i64,
+        max_range_size: IntegerRep,
     ) -> bool {
         // if num cols is too large then the extended k is too large
         if Self::calc_num_cols(safe_lookup_range.1 - safe_lookup_range.0, k) > MAX_NUM_LOOKUP_COLS
@@ -1224,8 +1245,7 @@ impl GraphCircuit {
         inputs: &mut [Tensor<Fp>],
         vk: Option<&VerifyingKey<G1Affine>>,
         srs: Option<&Scheme::ParamsProver>,
-        witness_gen: bool,
-        check_lookup: bool,
+        region_settings: RegionSettings,
     ) -> Result<GraphWitness, GraphError> {
         let original_inputs = inputs.to_vec();
 
@@ -1274,7 +1294,7 @@ impl GraphCircuit {
 
         let mut model_results =
             self.model()
-                .forward(inputs, &self.settings().run_args, witness_gen, check_lookup)?;
+                .forward(inputs, &self.settings().run_args, region_settings)?;
 
         if visibility.output.requires_processing() {
             let module_outlets = visibility.output.overwrites_inputs();

src/graph/model.rs

@@ -7,10 +7,12 @@ use super::GraphSettings;
 use crate::circuit::hybrid::HybridOp;
 use crate::circuit::region::ConstantsMap;
 use crate::circuit::region::RegionCtx;
+use crate::circuit::region::RegionSettings;
 use crate::circuit::table::Range;
 use crate::circuit::Input;
 use crate::circuit::InputType;
 use crate::circuit::Unknown;
+use crate::fieldutils::IntegerRep;
 use crate::tensor::ValType;
 use crate::{
     circuit::{lookup::LookupOp, BaseConfig as PolyConfig, CheckMode, Op},
@@ -64,11 +66,11 @@ pub struct ForwardResult {
     /// The outputs of the forward pass.
     pub outputs: Vec<Tensor<Fp>>,
     /// The maximum value of any input to a lookup operation.
-    pub max_lookup_inputs: i64,
+    pub max_lookup_inputs: IntegerRep,
     /// The minimum value of any input to a lookup operation.
-    pub min_lookup_inputs: i64,
+    pub min_lookup_inputs: IntegerRep,
     /// The max range check size
-    pub max_range_size: i64,
+    pub max_range_size: IntegerRep,
 }
 
 impl From<DummyPassRes> for ForwardResult {
@@ -116,11 +118,11 @@ pub struct DummyPassRes {
     /// range checks
     pub range_checks: HashSet<Range>,
     /// max lookup inputs
-    pub max_lookup_inputs: i64,
+    pub max_lookup_inputs: IntegerRep,
     /// min lookup inputs
-    pub min_lookup_inputs: i64,
+    pub min_lookup_inputs: IntegerRep,
     /// min range check
-    pub max_range_size: i64,
+    pub max_range_size: IntegerRep,
     /// outputs
     pub outputs: Vec<Tensor<Fp>>,
 }
@@ -545,7 +547,11 @@ impl Model {
             })
             .collect::<Result<Vec<_>, GraphError>>()?;
 
-        let res = self.dummy_layout(run_args, &inputs, false, false)?;
+        let res = self.dummy_layout(
+            run_args,
+            &inputs,
+            RegionSettings::all_false(run_args.decomp_base, run_args.decomp_legs),
+        )?;
 
         // if we're using percentage tolerance, we need to add the necessary range check ops for it.
 
@@ -588,14 +594,13 @@ impl Model {
         &self,
         model_inputs: &[Tensor<Fp>],
         run_args: &RunArgs,
-        witness_gen: bool,
-        check_lookup: bool,
+        region_settings: RegionSettings,
     ) -> Result<ForwardResult, GraphError> {
         let valtensor_inputs: Vec<ValTensor<Fp>> = model_inputs
             .iter()
             .map(|x| x.map(|elem| ValType::Value(Value::known(elem))).into())
             .collect();
-        let res = self.dummy_layout(run_args, &valtensor_inputs, witness_gen, check_lookup)?;
+        let res = self.dummy_layout(run_args, &valtensor_inputs, region_settings)?;
         Ok(res.into())
     }
 
@@ -609,9 +614,7 @@ impl Model {
         reader: &mut dyn std::io::Read,
         run_args: &RunArgs,
     ) -> Result<TractResult, GraphError> {
-        use tract_onnx::{
-            tract_core::internal::IntoArcTensor, tract_hir::internal::GenericFactoid,
-        };
+        use tract_onnx::tract_hir::internal::GenericFactoid;
 
         let mut model = tract_onnx::onnx().model_for_read(reader)?;
 
@@ -648,29 +651,11 @@ impl Model {
         }
 
         // Note: do not optimize the model, as the layout will depend on underlying hardware
-        let mut typed_model = model
+        let typed_model = model
             .into_typed()?
             .concretize_dims(&symbol_values)?
             .into_decluttered()?;
 
-        // concretize constants
-        for node in typed_model.eval_order()? {
-            let node = typed_model.node_mut(node);
-            if let Some(op) = node.op_as_mut::<tract_onnx::tract_core::ops::konst::Const>() {
-                if op.0.datum_type() == DatumType::TDim {
-                    // get inner value to Arc<Tensor>
-                    let mut constant = op.0.as_ref().clone();
-                    // Generally a shape or hyperparam
-                    constant
-                        .as_slice_mut::<tract_onnx::prelude::TDim>()?
-                        .iter_mut()
-                        .for_each(|x| *x = x.eval(&symbol_values));
-
-                    op.0 = constant.into_arc_tensor();
-                }
-            }
-        }
-
         Ok((typed_model, symbol_values))
     }
 
@@ -902,16 +887,8 @@ impl Model {
                     );
                 }
                 None => {
-                    let mut n = Node::new(
-                        n.clone(),
-                        &mut nodes,
-                        scales,
-                        &run_args.param_visibility,
-                        i,
-                        symbol_values,
-                        run_args.div_rebasing,
-                        run_args.rebase_frac_zero_constants,
-                    )?;
+                    let mut n =
+                        Node::new(n.clone(), &mut nodes, scales, i, symbol_values, run_args)?;
                     if let Some(ref scales) = override_input_scales {
                         if let Some(inp) = n.opkind.get_input() {
                             let scale = scales[input_idx];
@@ -1131,6 +1108,8 @@ impl Model {
                     region,
                     0,
                     run_args.num_inner_cols,
+                    run_args.decomp_base,
+                    run_args.decomp_legs,
                     original_constants.clone(),
                 );
                 // we need to do this as this loop is called multiple times
@@ -1410,8 +1389,7 @@ impl Model {
         &self,
         run_args: &RunArgs,
         inputs: &[ValTensor<Fp>],
-        witness_gen: bool,
-        check_lookup: bool,
+        region_settings: RegionSettings,
     ) -> Result<DummyPassRes, GraphError> {
         debug!("calculating num of constraints using dummy model layout...");
 
@@ -1430,8 +1408,7 @@ impl Model {
             vars: ModelVars::new_dummy(),
         };
 
-        let mut region =
-            RegionCtx::new_dummy(0, run_args.num_inner_cols, witness_gen, check_lookup);
+        let mut region = RegionCtx::new_dummy(0, run_args.num_inner_cols, region_settings);
 
         let outputs = self.layout_nodes(&mut model_config, &mut region, &mut results)?;
 

src/graph/node.rs

@@ -125,6 +125,7 @@ impl RebaseScale {
         if (op_out_scale > (global_scale * scale_rebase_multiplier as i32))
             && !inner.is_constant()
             && !inner.is_input()
+            && !inner.is_identity()
         {
             let multiplier =
                 scale_to_multiplier(op_out_scale - global_scale * scale_rebase_multiplier as i32);
@@ -326,6 +327,19 @@ impl SupportedOp {
             SupportedOp::RebaseScale(op) => op,
         }
     }
+
+    /// check if is the identity operation
+    /// # Returns
+    /// * `true` if the operation is the identity operation
+    /// * `false` otherwise
+    pub fn is_identity(&self) -> bool {
+        match self {
+            SupportedOp::Linear(op) => matches!(op, PolyOp::Identity { .. }),
+            SupportedOp::Rescaled(op) => op.inner.is_identity(),
+            SupportedOp::RebaseScale(op) => op.inner.is_identity(),
+            _ => false,
+        }
+    }
 }
 
 impl From<Box<dyn Op<Fp>>> for SupportedOp {
@@ -473,11 +487,9 @@ impl Node {
         node: OnnxNode<TypedFact, Box<dyn TypedOp>>,
         other_nodes: &mut BTreeMap<usize, super::NodeType>,
         scales: &VarScales,
-        param_visibility: &Visibility,
         idx: usize,
         symbol_values: &SymbolValues,
-        div_rebasing: bool,
-        rebase_frac_zero_constants: bool,
+        run_args: &crate::RunArgs,
     ) -> Result<Self, GraphError> {
         trace!("Create {:?}", node);
         trace!("Create op {:?}", node.op);
@@ -517,11 +529,10 @@ impl Node {
         let (mut opkind, deleted_indices) = new_op_from_onnx(
             idx,
             scales,
-            param_visibility,
             node.clone(),
             &mut inputs,
             symbol_values,
-            rebase_frac_zero_constants,
+            run_args,
         )?; // parses the op name
 
         // we can only take the inputs as mutable once -- so we need to collect them first
@@ -569,7 +580,7 @@ impl Node {
                     rescale_const_with_single_use(
                         constant,
                         in_scales.clone(),
-                        param_visibility,
+                        &run_args.param_visibility,
                         input_node.num_uses(),
                     )?;
                     input_node.replace_opkind(constant.clone_dyn().into());
@@ -589,7 +600,7 @@ impl Node {
             global_scale,
             out_scale,
             scales.rebase_multiplier,
-            div_rebasing,
+            run_args.div_rebasing,
         );
 
         out_scale = opkind.out_scale(in_scales)?;

src/graph/utilities.rs

@@ -9,6 +9,7 @@ use crate::circuit::lookup::LookupOp;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::circuit::poly::PolyOp;
 use crate::circuit::Op;
+use crate::fieldutils::IntegerRep;
 use crate::tensor::{Tensor, TensorError, TensorType};
 use halo2curves::bn256::Fr as Fp;
 use halo2curves::ff::PrimeField;
@@ -40,7 +41,7 @@ use tract_onnx::tract_hir::{
     ops::konst::Const,
     ops::nn::DataFormat,
     tract_core::ops::cast::Cast,
-    tract_core::ops::cnn::{conv::KernelFormat, MaxPool, PaddingSpec, SumPool},
+    tract_core::ops::cnn::{conv::KernelFormat, MaxPool, SumPool},
 };
 
 /// Quantizes an iterable of f32s to a [Tensor] of i32s using a fixed point representation.
@@ -50,16 +51,20 @@ use tract_onnx::tract_hir::{
 /// * `dims` - the dimensionality of the resulting [Tensor].
 /// * `shift` - offset used in the fixed point representation.
 /// * `scale` - `2^scale` used in the fixed point representation.
-pub fn quantize_float(elem: &f64, shift: f64, scale: crate::Scale) -> Result<i64, TensorError> {
+pub fn quantize_float(
+    elem: &f64,
+    shift: f64,
+    scale: crate::Scale,
+) -> Result<IntegerRep, TensorError> {
     let mult = scale_to_multiplier(scale);
-    let max_value = ((i64::MAX as f64 - shift) / mult).round(); // the maximum value that can be represented w/o sig bit truncation
+    let max_value = ((IntegerRep::MAX as f64 - shift) / mult).round(); // the maximum value that can be represented w/o sig bit truncation
 
     if *elem > max_value {
         return Err(TensorError::SigBitTruncationError);
     }
 
     // we parallelize the quantization process as it seems to be quite slow at times
-    let scaled = (mult * *elem + shift).round() as i64;
+    let scaled = (mult * *elem + shift).round() as IntegerRep;
 
     Ok(scaled)
 }
@@ -70,7 +75,7 @@ pub fn quantize_float(elem: &f64, shift: f64, scale: crate::Scale) -> Result<i64
 /// * `scale` - `2^scale` used in the fixed point representation.
 /// * `shift` - offset used in the fixed point representation.
 pub fn dequantize(felt: Fp, scale: crate::Scale, shift: f64) -> f64 {
-    let int_rep = crate::fieldutils::felt_to_i64(felt);
+    let int_rep = crate::fieldutils::felt_to_integer_rep(felt);
     let multiplier = scale_to_multiplier(scale);
     int_rep as f64 / multiplier - shift
 }
@@ -85,6 +90,35 @@ pub fn multiplier_to_scale(mult: f64) -> crate::Scale {
     mult.log2().round() as crate::Scale
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+/// extract padding from a onnx node.
+pub fn extract_padding(
+    pool_spec: &PoolSpec,
+    image_size: &[usize],
+) -> Result<Vec<(usize, usize)>, GraphError> {
+    let num_relevant_dims = pool_spec.kernel_shape.len();
+
+    // get the last num_relevant_dims of the image size
+    let image_size = &image_size[image_size.len() - num_relevant_dims..];
+
+    let dims = pool_spec.computed_padding(image_size);
+    let mut padding = Vec::new();
+    for dim in dims {
+        padding.push((dim.pad_before, dim.pad_after));
+    }
+    Ok(padding)
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+/// Extracts the strides from a onnx node.
+pub fn extract_strides(pool_spec: &PoolSpec) -> Result<Vec<usize>, GraphError> {
+    Ok(pool_spec
+        .strides
+        .clone()
+        .ok_or(GraphError::MissingParams("stride".to_string()))?
+        .to_vec())
+}
+
 /// Gets the shape of a onnx node's outlets.
 #[cfg(not(target_arch = "wasm32"))]
 pub fn node_output_shapes(
@@ -240,11 +274,10 @@ fn load_op<C: tract_onnx::prelude::Op + Clone>(
 pub fn new_op_from_onnx(
     idx: usize,
     scales: &VarScales,
-    param_visibility: &Visibility,
     node: OnnxNode<TypedFact, Box<dyn TypedOp>>,
     inputs: &mut [super::NodeType],
     symbol_values: &SymbolValues,
-    rebase_frac_zero_constants: bool,
+    run_args: &crate::RunArgs,
 ) -> Result<(SupportedOp, Vec<usize>), GraphError> {
     use tract_onnx::tract_core::ops::array::Trilu;
 
@@ -255,6 +288,8 @@ pub fn new_op_from_onnx(
         .flat_map(|x| x.out_scales())
         .collect::<Vec<_>>();
 
+    let input_dims = inputs.iter().flat_map(|x| x.out_dims()).collect::<Vec<_>>();
+
     let mut replace_const = |scale: crate::Scale,
                              index: usize,
                              default_op: SupportedOp|
@@ -309,12 +344,9 @@ pub fn new_op_from_onnx(
             }
         }
         "MultiBroadcastTo" => {
-            let op = load_op::<MultiBroadcastTo>(node.op(), idx, node.op().name().to_string())?;
-            let shape = op.shape.clone();
-            let shape = shape
-                .iter()
-                .map(|x| x.to_usize())
-                .collect::<Result<Vec<_>, _>>()?;
+            let _op = load_op::<MultiBroadcastTo>(node.op(), idx, node.op().name().to_string())?;
+            let shapes = node_output_shapes(&node, symbol_values)?;
+            let shape = shapes[0].clone();
             SupportedOp::Linear(PolyOp::MultiBroadcastTo { shape })
         }
 
@@ -632,13 +664,16 @@ pub fn new_op_from_onnx(
 
             // if all raw_values are round then set scale to 0
             let all_round = raw_value.iter().all(|x| (x).fract() == 0.0);
-            if all_round && rebase_frac_zero_constants {
+            if all_round && run_args.rebase_frac_zero_constants {
                 constant_scale = 0;
             }
 
             // Quantize the raw value
-            let quantized_value =
-                quantize_tensor(raw_value.clone(), constant_scale, param_visibility)?;
+            let quantized_value = quantize_tensor(
+                raw_value.clone(),
+                constant_scale,
+                &run_args.param_visibility,
+            )?;
             let c = crate::circuit::ops::Constant::new(quantized_value, raw_value);
             // Create a constant op
             SupportedOp::Constant(c)
@@ -750,7 +785,7 @@ pub fn new_op_from_onnx(
                     deleted_indices.push(const_idx);
                 }
                 if unit == 0. {
-                    SupportedOp::Nonlinear(LookupOp::ReLU)
+                    SupportedOp::Linear(PolyOp::ReLU)
                 } else {
                     // get the non-constant index
                     let non_const_idx = if const_idx == 0 { 1 } else { 0 };
@@ -839,7 +874,7 @@ pub fn new_op_from_onnx(
         "QuantizeLinearU8" | "DequantizeLinearF32" => {
             SupportedOp::Linear(PolyOp::Identity { out_scale: None })
         }
-        "Abs" => SupportedOp::Nonlinear(LookupOp::Abs),
+        "Abs" => SupportedOp::Linear(PolyOp::Abs),
         "Neg" => SupportedOp::Linear(PolyOp::Neg),
         "HardSwish" => SupportedOp::Nonlinear(LookupOp::HardSwish {
             scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
@@ -982,8 +1017,13 @@ pub fn new_op_from_onnx(
                         if raw_values.log2().fract() == 0.0 {
                             inputs[const_idx].decrement_use();
                             deleted_indices.push(const_idx);
+                            // get the non constant index
+                            let non_const_idx = if const_idx == 0 { 1 } else { 0 };
+
                             op = SupportedOp::Linear(PolyOp::Identity {
-                                out_scale: Some(input_scales[0] + raw_values.log2() as i32),
+                                out_scale: Some(
+                                    input_scales[non_const_idx] + raw_values.log2() as i32,
+                                ),
                             });
                         }
                     }
@@ -1073,18 +1113,8 @@ pub fn new_op_from_onnx(
                 ));
             }
 
-            let stride = pool_spec
-                .strides
-                .clone()
-                .ok_or(GraphError::MissingParams("stride".to_string()))?;
-            let padding = match &pool_spec.padding {
-                PaddingSpec::Explicit(b, a) | PaddingSpec::ExplicitOnnxPool(b, a, _) => {
-                    b.iter().zip(a.iter()).map(|(b, a)| (*b, *a)).collect()
-                }
-                _ => {
-                    return Err(GraphError::MissingParams("padding".to_string()));
-                }
-            };
+            let stride = extract_strides(pool_spec)?;
+            let padding = extract_padding(pool_spec, &input_dims[0])?;
             let kernel_shape = &pool_spec.kernel_shape;
 
             SupportedOp::Hybrid(HybridOp::MaxPool {
@@ -1105,7 +1135,7 @@ pub fn new_op_from_onnx(
         "RoundHalfToEven" => SupportedOp::Nonlinear(LookupOp::RoundHalfToEven {
             scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
         }),
-        "Sign" => SupportedOp::Nonlinear(LookupOp::Sign),
+        "Sign" => SupportedOp::Linear(PolyOp::Sign),
         "Pow" => {
             // Extract the slope layer hyperparams from a const
 
@@ -1151,21 +1181,10 @@ pub fn new_op_from_onnx(
                 ));
             }
 
-            let stride = match conv_node.pool_spec.strides.clone() {
-                Some(s) => s.to_vec(),
-                None => {
-                    return Err(GraphError::MissingParams("strides".to_string()));
-                }
-            };
+            let pool_spec = &conv_node.pool_spec;
 
-            let padding = match &conv_node.pool_spec.padding {
-                PaddingSpec::Explicit(b, a) | PaddingSpec::ExplicitOnnxPool(b, a, _) => {
-                    b.iter().zip(a.iter()).map(|(b, a)| (*b, *a)).collect()
-                }
-                _ => {
-                    return Err(GraphError::MissingParams("padding".to_string()));
-                }
-            };
+            let stride = extract_strides(pool_spec)?;
+            let padding = extract_padding(pool_spec, &input_dims[0])?;
 
             // if bias exists then rescale it to the input + kernel scale
             if input_scales.len() == 3 {
@@ -1183,7 +1202,13 @@ pub fn new_op_from_onnx(
                 }
             }
 
-            SupportedOp::Linear(PolyOp::Conv { padding, stride })
+            let group = conv_node.group;
+
+            SupportedOp::Linear(PolyOp::Conv {
+                padding,
+                stride,
+                group,
+            })
         }
         "Not" => SupportedOp::Linear(PolyOp::Not),
         "And" => SupportedOp::Linear(PolyOp::And),
@@ -1214,21 +1239,10 @@ pub fn new_op_from_onnx(
                 ));
             }
 
-            let stride = match deconv_node.pool_spec.strides.clone() {
-                Some(s) => s.to_vec(),
-                None => {
-                    return Err(GraphError::MissingParams("strides".to_string()));
-                }
-            };
-            let padding = match &deconv_node.pool_spec.padding {
-                PaddingSpec::Explicit(b, a) | PaddingSpec::ExplicitOnnxPool(b, a, _) => {
-                    b.iter().zip(a.iter()).map(|(b, a)| (*b, *a)).collect()
-                }
-                _ => {
-                    return Err(GraphError::MissingParams("padding".to_string()));
-                }
-            };
+            let pool_spec = &deconv_node.pool_spec;
 
+            let stride = extract_strides(pool_spec)?;
+            let padding = extract_padding(pool_spec, &input_dims[0])?;
             // if bias exists then rescale it to the input + kernel scale
             if input_scales.len() == 3 {
                 let bias_scale = input_scales[2];
@@ -1249,6 +1263,7 @@ pub fn new_op_from_onnx(
                 padding,
                 output_padding: deconv_node.adjustments.to_vec(),
                 stride,
+                group: deconv_node.group,
             })
         }
         "Downsample" => {
@@ -1339,18 +1354,8 @@ pub fn new_op_from_onnx(
                 ));
             }
 
-            let stride = pool_spec
-                .strides
-                .clone()
-                .ok_or(GraphError::MissingParams("stride".to_string()))?;
-            let padding = match &pool_spec.padding {
-                PaddingSpec::Explicit(b, a) | PaddingSpec::ExplicitOnnxPool(b, a, _) => {
-                    b.iter().zip(a.iter()).map(|(b, a)| (*b, *a)).collect()
-                }
-                _ => {
-                    return Err(GraphError::MissingParams("padding".to_string()));
-                }
-            };
+            let stride = extract_strides(pool_spec)?;
+            let padding = extract_padding(pool_spec, &input_dims[0])?;
 
             SupportedOp::Hybrid(HybridOp::SumPool {
                 padding,
@@ -1359,11 +1364,6 @@ pub fn new_op_from_onnx(
                 normalized: sumpool_node.normalize,
             })
         }
-        // "GlobalAvgPool" => SupportedOp::Linear(PolyOp::SumPool {
-        //     padding: [(0, 0); 2],
-        //     stride: (1, 1),
-        //     kernel_shape: (inputs[0].out_dims()[0][1], inputs[0].out_dims()[0][2]),
-        // }),
         "Pad" => {
             let pad_node: &Pad = match node.op().downcast_ref::<Pad>() {
                 Some(b) => b,
@@ -1432,7 +1432,7 @@ pub fn quantize_tensor<F: PrimeField + TensorType + PartialOrd>(
     visibility: &Visibility,
 ) -> Result<Tensor<F>, TensorError> {
     let mut value: Tensor<F> = const_value.par_enum_map(|_, x| {
-        Ok::<_, TensorError>(crate::fieldutils::i64_to_felt::<F>(quantize_float(
+        Ok::<_, TensorError>(crate::fieldutils::integer_rep_to_felt::<F>(quantize_float(
             &(x).into(),
             0.0,
             scale,

src/lib.rs

@@ -23,6 +23,7 @@
 )]
 // we allow this for our dynamic range based indexing scheme
 #![allow(clippy::single_range_in_vec_init)]
+#![feature(buf_read_has_data_left)]
 #![feature(stmt_expr_attributes)]
 
 //! A library for turning computational graphs, such as neural networks, into ZK-circuits.
@@ -85,6 +86,7 @@ use std::str::FromStr;
 
 use circuit::{table::Range, CheckMode, Tolerance};
 use clap::Args;
+use fieldutils::IntegerRep;
 use graph::Visibility;
 use halo2_proofs::poly::{
     ipa::commitment::IPACommitmentScheme, kzg::commitment::KZGCommitmentScheme,
@@ -148,6 +150,7 @@ lazy_static! {
     /// The serialization format for the keys
     pub static ref EZKL_KEY_FORMAT: String = std::env::var("EZKL_KEY_FORMAT")
         .unwrap_or("raw-bytes".to_string());
+
 }
 
 #[cfg(target_arch = "wasm32")]
@@ -243,7 +246,7 @@ pub struct RunArgs {
     #[arg(long, default_value = "1",  value_hint = clap::ValueHint::Other)]
     pub scale_rebase_multiplier: u32,
     /// The min and max elements in the lookup table input column
-    #[arg(short = 'B', long, value_parser = parse_key_val::<i64, i64>, default_value = "-32768->32768")]
+    #[arg(short = 'B', long, value_parser = parse_key_val::<IntegerRep, IntegerRep>, default_value = "-32768->32768")]
     pub lookup_range: Range,
     /// The log_2 number of rows
     #[arg(short = 'K', long, default_value = "17", value_hint = clap::ValueHint::Other)]
@@ -275,6 +278,12 @@ pub struct RunArgs {
     /// commitment scheme
     #[arg(long, default_value = "kzg", value_hint = clap::ValueHint::Other)]
     pub commitment: Option<Commitments>,
+    /// the base used for decompositions
+    #[arg(long, default_value = "16384", value_hint = clap::ValueHint::Other)]
+    pub decomp_base: usize,
+    #[arg(long, default_value = "2", value_hint = clap::ValueHint::Other)]
+    /// the number of legs used for decompositions
+    pub decomp_legs: usize,
 }
 
 impl Default for RunArgs {
@@ -295,6 +304,8 @@ impl Default for RunArgs {
             rebase_frac_zero_constants: false,
             check_mode: CheckMode::UNSAFE,
             commitment: None,
+            decomp_base: 16384,
+            decomp_legs: 2,
         }
     }
 }

src/logger.rs

@@ -76,7 +76,7 @@ pub fn init_logger() {
             prefix_token(&record.level()),
             //    pretty print UTC time
             chrono::Utc::now()
-                .format("%Y-%m-%d %H:%M:%S")
+                .format("%Y-%m-%d %H:%M:%S:%3f")
                 .to_string()
                 .bright_magenta(),
             record.metadata().target(),

src/pfsys/mod.rs

@@ -558,7 +558,8 @@ where
         + PrimeField
         + FromUniformBytes<64>
         + WithSmallOrderMulGroup<3>,
-    Scheme::Curve: Serialize + DeserializeOwned,
+    Scheme::Curve: Serialize + DeserializeOwned + SerdeObject,
+    Scheme::ParamsProver: Send + Sync,
 {
     let strategy = Strategy::new(params.verifier_params());
     let mut transcript = TranscriptWriterBuffer::<_, Scheme::Curve, _>::init(vec![]);

src/python.rs

@@ -6,7 +6,7 @@ use crate::circuit::modules::poseidon::{
 use crate::circuit::modules::Module;
 use crate::circuit::{CheckMode, Tolerance};
 use crate::commands::*;
-use crate::fieldutils::{felt_to_i64, i64_to_felt};
+use crate::fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep};
 use crate::graph::modules::POSEIDON_LEN_GRAPH;
 use crate::graph::TestDataSource;
 use crate::graph::{
@@ -191,6 +191,12 @@ struct PyRunArgs {
     #[pyo3(get, set)]
     /// str: commitment type, accepts `kzg`, `ipa`
     pub commitment: PyCommitments,
+    /// int: The base used for decomposition
+    #[pyo3(get, set)]
+    pub decomp_base: usize,
+    /// int: The number of legs used for decomposition
+    #[pyo3(get, set)]
+    pub decomp_legs: usize,
 }
 
 /// default instantiation of PyRunArgs
@@ -221,6 +227,8 @@ impl From<PyRunArgs> for RunArgs {
             rebase_frac_zero_constants: py_run_args.rebase_frac_zero_constants,
             check_mode: py_run_args.check_mode,
             commitment: Some(py_run_args.commitment.into()),
+            decomp_base: py_run_args.decomp_base,
+            decomp_legs: py_run_args.decomp_legs,
         }
     }
 }
@@ -243,6 +251,8 @@ impl Into<PyRunArgs> for RunArgs {
             rebase_frac_zero_constants: self.rebase_frac_zero_constants,
             check_mode: self.check_mode,
             commitment: self.commitment.into(),
+            decomp_base: self.decomp_base,
+            decomp_legs: self.decomp_legs,
         }
     }
 }
@@ -331,9 +341,9 @@ fn felt_to_big_endian(felt: PyFelt) -> PyResult<String> {
 #[pyfunction(signature = (
     felt,
 ))]
-fn felt_to_int(felt: PyFelt) -> PyResult<i64> {
+fn felt_to_int(felt: PyFelt) -> PyResult<IntegerRep> {
     let felt = crate::pfsys::string_to_field::<Fr>(&felt);
-    let int_rep = felt_to_i64(felt);
+    let int_rep = felt_to_integer_rep(felt);
     Ok(int_rep)
 }
 
@@ -357,7 +367,7 @@ fn felt_to_int(felt: PyFelt) -> PyResult<i64> {
 ))]
 fn felt_to_float(felt: PyFelt, scale: crate::Scale) -> PyResult<f64> {
     let felt = crate::pfsys::string_to_field::<Fr>(&felt);
-    let int_rep = felt_to_i64(felt);
+    let int_rep = felt_to_integer_rep(felt);
     let multiplier = scale_to_multiplier(scale);
     let float_rep = int_rep as f64 / multiplier;
     Ok(float_rep)
@@ -385,7 +395,7 @@ fn felt_to_float(felt: PyFelt, scale: crate::Scale) -> PyResult<f64> {
 fn float_to_felt(input: f64, scale: crate::Scale) -> PyResult<PyFelt> {
     let int_rep = quantize_float(&input, 0.0, scale)
         .map_err(|_| PyIOError::new_err("Failed to quantize input"))?;
-    let felt = i64_to_felt(int_rep);
+    let felt = integer_rep_to_felt(int_rep);
     Ok(crate::pfsys::field_to_string::<Fr>(&felt))
 }
 
@@ -1490,8 +1500,8 @@ fn encode_evm_calldata<'a>(
 /// srs_path: str
 ///     The path to the SRS file
 ///
-/// render_vk_separately: bool
-///     Whether the verifier key should be rendered as a separate contract. We recommend disabling selector compression if this is enabled. To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command
+/// reusable: bool
+///     Whether the verifier should be rendered as a reusable contract. If so, then you will need to deploy the VK artifact separately which you can generate using the create_evm_vka command
 ///
 /// Returns
 /// -------
@@ -1503,7 +1513,7 @@ fn encode_evm_calldata<'a>(
     sol_code_path=PathBuf::from(DEFAULT_SOL_CODE),
     abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
     srs_path=None,
-    render_vk_seperately = DEFAULT_RENDER_VK_SEPERATELY.parse().unwrap(),
+    reusable = DEFAULT_RENDER_REUSABLE.parse().unwrap(),
 ))]
 fn create_evm_verifier(
     py: Python,
@@ -1512,7 +1522,7 @@ fn create_evm_verifier(
     sol_code_path: PathBuf,
     abi_path: PathBuf,
     srs_path: Option<PathBuf>,
-    render_vk_seperately: bool,
+    reusable: bool,
 ) -> PyResult<Bound<'_, PyAny>> {
     pyo3_asyncio::tokio::future_into_py(py, async move {
         crate::execute::create_evm_verifier(
@@ -1521,7 +1531,7 @@ fn create_evm_verifier(
             settings_path,
             sol_code_path,
             abi_path,
-            render_vk_seperately,
+            reusable,
         )
         .await
         .map_err(|e| {
@@ -1533,6 +1543,57 @@ fn create_evm_verifier(
     })
 }
 
+/// Creates an Evm VK artifact. This command generated a VK with circuit specific meta data encoding in memory for use by the reusable H2 verifier.
+/// This is useful for deploying verifier that were otherwise too big to fit on chain and required aggregation.
+///
+/// Arguments
+/// ---------
+/// vk_path: str
+///     The path to the verification key file
+///
+/// settings_path: str
+///     The path to the settings file
+///
+/// sol_code_path: str
+///     The path to the create the solidity verifying key.
+///
+/// abi_path: str
+///     The path to create the ABI for the solidity verifier
+///
+/// srs_path: str
+///     The path to the SRS file
+///
+/// Returns
+/// -------
+/// bool
+///
+#[pyfunction(signature = (
+    vk_path=PathBuf::from(DEFAULT_VK),
+    settings_path=PathBuf::from(DEFAULT_SETTINGS),
+    sol_code_path=PathBuf::from(DEFAULT_VK_SOL),
+    abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
+    srs_path=None
+))]
+fn create_evm_vka(
+    py: Python,
+    vk_path: PathBuf,
+    settings_path: PathBuf,
+    sol_code_path: PathBuf,
+    abi_path: PathBuf,
+    srs_path: Option<PathBuf>,
+) -> PyResult<Bound<'_, PyAny>> {
+    pyo3_asyncio::tokio::future_into_py(py, async move {
+        crate::execute::create_evm_vka(vk_path, srs_path, settings_path, sol_code_path, abi_path)
+            .await
+            .map_err(|e| {
+                let err_str = format!("Failed to run create_evm_verifier: {}", e);
+                PyRuntimeError::new_err(err_str)
+            })?;
+
+        Ok(true)
+    })
+}
+
 /// Creates an EVM compatible data attestation verifier, you will need solc installed in your environment to run this
 ///
 /// Arguments
@@ -1653,6 +1714,7 @@ fn setup_test_evm_witness(
     addr_path,
     sol_code_path=PathBuf::from(DEFAULT_SOL_CODE),
     rpc_url=None,
+    contract_type=ContractType::default(),
     optimizer_runs=DEFAULT_OPTIMIZER_RUNS.parse().unwrap(),
     private_key=None,
 ))]
@@ -1661,6 +1723,7 @@ fn deploy_evm(
     addr_path: PathBuf,
     sol_code_path: PathBuf,
     rpc_url: Option<String>,
+    contract_type: ContractType,
     optimizer_runs: usize,
     private_key: Option<String>,
 ) -> PyResult<Bound<'_, PyAny>> {
@@ -1671,42 +1734,7 @@ fn deploy_evm(
             addr_path,
             optimizer_runs,
             private_key,
-            "Halo2Verifier",
-        )
-        .await
-        .map_err(|e| {
-            let err_str = format!("Failed to run deploy_evm: {}", e);
-            PyRuntimeError::new_err(err_str)
-        })?;
-
-        Ok(true)
-    })
-}
-
-/// deploys the solidity vk verifier
-#[pyfunction(signature = (
-    addr_path,
-    sol_code_path=PathBuf::from(DEFAULT_VK_SOL),
-    rpc_url=None,
-    optimizer_runs=DEFAULT_OPTIMIZER_RUNS.parse().unwrap(),
-    private_key=None,
-))]
-fn deploy_vk_evm(
-    py: Python,
-    addr_path: PathBuf,
-    sol_code_path: PathBuf,
-    rpc_url: Option<String>,
-    optimizer_runs: usize,
-    private_key: Option<String>,
-) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_asyncio::tokio::future_into_py(py, async move {
-        crate::execute::deploy_evm(
-            sol_code_path,
-            rpc_url,
-            addr_path,
-            optimizer_runs,
-            private_key,
-            "Halo2VerifyingKey",
+            contract_type,
         )
         .await
         .map_err(|e| {
@@ -1762,7 +1790,7 @@ fn deploy_da_evm(
 /// Arguments
 /// ---------
 /// addr_verifier: str
-///     The path to verifier contract's address
+///     The verifier contract's address as a hex string
 ///
 /// proof_path: str
 ///     The path to the proof file (generated using the prove command)
@@ -1774,7 +1802,7 @@ fn deploy_da_evm(
 ///     does the verifier use data attestation ?
 ///
 /// addr_vk: str
-///
+///     The addess of the separate VK contract (if the verifier key is rendered as a separate contract)
 /// Returns
 /// -------
 /// bool
@@ -1842,8 +1870,8 @@ fn verify_evm<'a>(
 /// srs_path: str
 ///     The path to the SRS file
 ///
-/// render_vk_separately: bool
-///     Whether the verifier key should be rendered as a separate contract. We recommend disabling selector compression if this is enabled. To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command
+/// reusable: bool
+///     Whether the verifier should be rendered as a reusable contract. If so, then you will need to deploy the VK artifact separately which you can generate using the create_evm_vka command
 ///
 /// Returns
 /// -------
@@ -1856,7 +1884,7 @@ fn verify_evm<'a>(
     abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
     logrows=DEFAULT_AGGREGATED_LOGROWS.parse().unwrap(),
     srs_path=None,
-    render_vk_seperately = DEFAULT_RENDER_VK_SEPERATELY.parse().unwrap(),
+    reusable = DEFAULT_RENDER_REUSABLE.parse().unwrap(),
 ))]
 fn create_evm_verifier_aggr(
     py: Python,
@@ -1866,7 +1894,7 @@ fn create_evm_verifier_aggr(
     abi_path: PathBuf,
     logrows: u32,
     srs_path: Option<PathBuf>,
-    render_vk_seperately: bool,
+    reusable: bool,
 ) -> PyResult<Bound<'_, PyAny>> {
     pyo3_asyncio::tokio::future_into_py(py, async move {
         crate::execute::create_evm_aggregate_verifier(
@@ -1876,7 +1904,7 @@ fn create_evm_verifier_aggr(
             abi_path,
             aggregation_settings,
             logrows,
-            render_vk_seperately,
+            reusable,
         )
         .await
         .map_err(|e| {
@@ -1925,8 +1953,8 @@ fn ezkl(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(compile_circuit, m)?)?;
     m.add_function(wrap_pyfunction!(verify_aggr, m)?)?;
     m.add_function(wrap_pyfunction!(create_evm_verifier, m)?)?;
+    m.add_function(wrap_pyfunction!(create_evm_vka, m)?)?;
     m.add_function(wrap_pyfunction!(deploy_evm, m)?)?;
-    m.add_function(wrap_pyfunction!(deploy_vk_evm, m)?)?;
     m.add_function(wrap_pyfunction!(deploy_da_evm, m)?)?;
     m.add_function(wrap_pyfunction!(verify_evm, m)?)?;
     m.add_function(wrap_pyfunction!(setup_test_evm_witness, m)?)?;

src/tensor/errors.rs

@@ -1,5 +1,7 @@
 use thiserror::Error;
 
+use super::ops::DecompositionError;
+
 /// A wrapper for tensor related errors.
 #[derive(Debug, Error)]
 pub enum TensorError {
@@ -27,4 +29,13 @@ pub enum TensorError {
     /// Unset visibility
     #[error("unset visibility")]
     UnsetVisibility,
+    /// File save error
+    #[error("save error: {0}")]
+    FileSaveError(String),
+    /// File load error
+    #[error("load error: {0}")]
+    FileLoadError(String),
+    /// Decomposition error
+    #[error("decomposition error: {0}")]
+    DecompositionError(#[from] DecompositionError),
 }

src/tensor/val.rs

@@ -1,12 +1,12 @@
-use core::{iter::FilterMap, slice::Iter};
-
-use crate::circuit::region::ConstantsMap;
+use crate::{circuit::region::ConstantsMap, fieldutils::felt_to_integer_rep};
+use maybe_rayon::slice::Iter;
 
 use super::{
     ops::{intercalate_values, pad, resize},
     *,
 };
 use halo2_proofs::{arithmetic::Field, circuit::Cell, plonk::Instance};
+use maybe_rayon::iter::{FilterMap, IntoParallelIterator, ParallelIterator};
 
 pub(crate) fn create_constant_tensor<
     F: PrimeField + TensorType + std::marker::Send + std::marker::Sync + PartialOrd,
@@ -54,6 +54,44 @@ pub enum ValType<F: PrimeField + TensorType + std::marker::Send + std::marker::S
     AssignedConstant(AssignedCell<F, F>, F),
 }
 
+impl<F: PrimeField + TensorType + PartialOrd> From<ValType<F>> for IntegerRep {
+    fn from(val: ValType<F>) -> Self {
+        match val {
+            ValType::Value(v) => {
+                let mut output = 0;
+                let mut i = 0;
+                v.map(|y| {
+                    let e = felt_to_integer_rep(y);
+                    output = e;
+                    i += 1;
+                });
+                output
+            }
+            ValType::AssignedValue(v) => {
+                let mut output = 0;
+                let mut i = 0;
+                v.evaluate().map(|y| {
+                    let e = felt_to_integer_rep(y);
+                    output = e;
+                    i += 1;
+                });
+                output
+            }
+            ValType::PrevAssigned(v) | ValType::AssignedConstant(v, ..) => {
+                let mut output = 0;
+                let mut i = 0;
+                v.value().map(|y| {
+                    let e = felt_to_integer_rep(*y);
+                    output = e;
+                    i += 1;
+                });
+                output
+            }
+            ValType::Constant(v) => felt_to_integer_rep(v),
+        }
+    }
+}
+
 impl<F: PrimeField + TensorType + std::marker::Send + std::marker::Sync + PartialOrd> ValType<F> {
     /// Returns the inner cell of the [ValType].
     pub fn cell(&self) -> Option<Cell> {
@@ -121,44 +159,6 @@ impl<F: PrimeField + TensorType + std::marker::Send + std::marker::Sync + Partia
     }
 }
 
-impl<F: PrimeField + TensorType + PartialOrd> From<ValType<F>> for i32 {
-    fn from(val: ValType<F>) -> Self {
-        match val {
-            ValType::Value(v) => {
-                let mut output = 0_i32;
-                let mut i = 0;
-                v.map(|y| {
-                    let e = felt_to_i32(y);
-                    output = e;
-                    i += 1;
-                });
-                output
-            }
-            ValType::AssignedValue(v) => {
-                let mut output = 0_i32;
-                let mut i = 0;
-                v.evaluate().map(|y| {
-                    let e = felt_to_i32(y);
-                    output = e;
-                    i += 1;
-                });
-                output
-            }
-            ValType::PrevAssigned(v) | ValType::AssignedConstant(v, ..) => {
-                let mut output = 0_i32;
-                let mut i = 0;
-                v.value().map(|y| {
-                    let e = felt_to_i32(*y);
-                    output = e;
-                    i += 1;
-                });
-                output
-            }
-            ValType::Constant(v) => felt_to_i32(v),
-        }
-    }
-}
-
 impl<F: PrimeField + TensorType + PartialOrd> From<F> for ValType<F> {
     fn from(t: F) -> ValType<F> {
         ValType::Constant(t)
@@ -317,8 +317,8 @@ impl<F: PrimeField + TensorType + PartialOrd> From<Tensor<AssignedCell<F, F>>> f
 
 impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
     /// Allocate a new [ValTensor::Value] from the given [Tensor] of [i64].
-    pub fn from_i64_tensor(t: Tensor<i64>) -> ValTensor<F> {
-        let inner = t.map(|x| ValType::Value(Value::known(i64_to_felt(x))));
+    pub fn from_integer_rep_tensor(t: Tensor<IntegerRep>) -> ValTensor<F> {
+        let inner = t.map(|x| ValType::Value(Value::known(integer_rep_to_felt(x))));
         inner.into()
     }
 
@@ -460,7 +460,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
         &self,
     ) -> FilterMap<Iter<'_, ValType<F>>, fn(&ValType<F>) -> Option<(F, ValType<F>)>> {
         match self {
-            ValTensor::Value { inner, .. } => inner.iter().filter_map(|x| {
+            ValTensor::Value { inner, .. } => inner.par_iter().filter_map(|x| {
                 if let ValType::Constant(v) = x {
                     Some((*v, x.clone()))
                 } else {
@@ -520,10 +520,58 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
         }
     }
 
+    /// Get the sign of the inner values
+    pub fn sign(&self) -> Result<Self, TensorError> {
+        let evals = self.int_evals()?;
+        Ok(evals
+            .par_enum_map(|_, val| {
+                Ok::<_, TensorError>(ValType::Value(Value::known(integer_rep_to_felt(
+                    val.signum(),
+                ))))
+            })?
+            .into())
+    }
+
+    /// Decompose the inner values into base `base` and `n` legs.
+    pub fn decompose(&self, base: usize, n: usize) -> Result<Self, TensorError> {
+        let res = self
+            .get_inner()?
+            .par_iter()
+            .map(|x| {
+                let mut is_empty = true;
+                x.map(|_| is_empty = false);
+                if is_empty {
+                    return Ok::<_, TensorError>(vec![Value::<F>::unknown(); n + 1]);
+                } else {
+                    let mut res = vec![Value::unknown(); n + 1];
+                    let mut int_rep = 0;
+
+                    x.map(|f| {
+                        int_rep = crate::fieldutils::felt_to_integer_rep(f);
+                    });
+                    let decompe = crate::tensor::ops::get_rep(&int_rep, base, n)?;
+
+                    for (i, x) in decompe.iter().enumerate() {
+                        res[i] = Value::known(crate::fieldutils::integer_rep_to_felt(*x));
+                    }
+                    Ok(res)
+                }
+            })
+            .collect::<Result<Vec<_>, _>>();
+
+        let mut tensor = Tensor::from(res?.into_iter().flatten().collect::<Vec<_>>().into_iter());
+        let mut dims = self.dims().to_vec();
+        dims.push(n + 1);
+
+        tensor.reshape(&dims)?;
+
+        Ok(tensor.into())
+    }
+
     /// Calls `int_evals` on the inner tensor.
-    pub fn get_int_evals(&self) -> Result<Tensor<i64>, TensorError> {
+    pub fn int_evals(&self) -> Result<Tensor<IntegerRep>, TensorError> {
         // finally convert to vector of integers
-        let mut integer_evals: Vec<i64> = vec![];
+        let mut integer_evals: Vec<IntegerRep> = vec![];
         match self {
             ValTensor::Value {
                 inner: v, dims: _, ..
@@ -531,25 +579,26 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
                 // we have to push to an externally created vector or else vaf.map() returns an evaluation wrapped in Value<> (which we don't want)
                 let _ = v.map(|vaf| match vaf {
                     ValType::Value(v) => v.map(|f| {
-                        integer_evals.push(crate::fieldutils::felt_to_i64(f));
+                        integer_evals.push(crate::fieldutils::felt_to_integer_rep(f));
                     }),
                     ValType::AssignedValue(v) => v.map(|f| {
-                        integer_evals.push(crate::fieldutils::felt_to_i64(f.evaluate()));
+                        integer_evals.push(crate::fieldutils::felt_to_integer_rep(f.evaluate()));
                     }),
                     ValType::PrevAssigned(v) | ValType::AssignedConstant(v, ..) => {
                         v.value_field().map(|f| {
-                            integer_evals.push(crate::fieldutils::felt_to_i64(f.evaluate()));
+                            integer_evals
+                                .push(crate::fieldutils::felt_to_integer_rep(f.evaluate()));
                         })
                     }
                     ValType::Constant(v) => {
-                        integer_evals.push(crate::fieldutils::felt_to_i64(v));
+                        integer_evals.push(crate::fieldutils::felt_to_integer_rep(v));
                         Value::unknown()
                     }
                 });
             }
             _ => return Err(TensorError::WrongMethod),
         };
-        let mut tensor: Tensor<i64> = integer_evals.into_iter().into();
+        let mut tensor: Tensor<IntegerRep> = integer_evals.into_iter().into();
         match tensor.reshape(self.dims()) {
             _ => {}
         };
@@ -573,6 +622,48 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
         Ok(())
     }
 
+    /// Calls `last` on the inner tensor.
+    pub fn last(&self) -> Result<ValTensor<F>, TensorError> {
+        let slice = match self {
+            ValTensor::Value {
+                inner: v,
+                dims: _,
+                scale,
+            } => {
+                let inner = v.last()?;
+                let dims = inner.dims().to_vec();
+                ValTensor::Value {
+                    inner,
+                    dims,
+                    scale: *scale,
+                }
+            }
+            _ => return Err(TensorError::WrongMethod),
+        };
+        Ok(slice)
+    }
+
+    /// Calls `first`
+    pub fn first(&self) -> Result<ValTensor<F>, TensorError> {
+        let slice = match self {
+            ValTensor::Value {
+                inner: v,
+                dims: _,
+                scale,
+            } => {
+                let inner = v.first()?;
+                let dims = inner.dims().to_vec();
+                ValTensor::Value {
+                    inner,
+                    dims,
+                    scale: *scale,
+                }
+            }
+            _ => return Err(TensorError::WrongMethod),
+        };
+        Ok(slice)
+    }
+
     /// Calls `get_slice` on the inner tensor.
     pub fn get_slice(&self, indices: &[Range<usize>]) -> Result<ValTensor<F>, TensorError> {
         if indices.iter().map(|x| x.end - x.start).collect::<Vec<_>>() == self.dims() {
@@ -753,43 +844,104 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
         Ok(())
     }
 
-    /// gets constants
-    pub fn get_const_zero_indices(&self) -> Result<Vec<usize>, TensorError> {
+    /// Calls `get_every_n` on the inner [Tensor].
+    pub fn get_every_n(&mut self, n: usize) -> Result<(), TensorError> {
         match self {
-            ValTensor::Value { inner: v, .. } => {
-                let mut indices = vec![];
-                for (i, e) in v.iter().enumerate() {
-                    if let ValType::Constant(r) = e {
-                        if *r == F::ZERO {
-                            indices.push(i);
-                        }
-                    } else if let ValType::AssignedConstant(_, r) = e {
-                        if *r == F::ZERO {
-                            indices.push(i);
-                        }
-                    }
-                }
-                Ok(indices)
+            ValTensor::Value {
+                inner: v, dims: d, ..
+            } => {
+                *v = v.get_every_n(n)?;
+                *d = v.dims().to_vec();
             }
-            ValTensor::Instance { .. } => Ok(vec![]),
+            ValTensor::Instance { .. } => {
+                return Err(TensorError::WrongMethod);
+            }
+        }
+        Ok(())
+    }
+
+    /// Calls `exclude_every_n` on the inner [Tensor].
+    pub fn exclude_every_n(&mut self, n: usize) -> Result<(), TensorError> {
+        match self {
+            ValTensor::Value {
+                inner: v, dims: d, ..
+            } => {
+                *v = v.exclude_every_n(n)?;
+                *d = v.dims().to_vec();
+            }
+            ValTensor::Instance { .. } => {
+                return Err(TensorError::WrongMethod);
+            }
+        }
+        Ok(())
+    }
+
+    /// remove constant zero values constants
+    pub fn remove_const_zero_values(&mut self) {
+        match self {
+            ValTensor::Value { inner: v, dims, .. } => {
+                *v = v
+                    .clone()
+                    .into_par_iter()
+                    .filter_map(|e| {
+                        if let ValType::Constant(r) = e {
+                            if r == F::ZERO {
+                                return None;
+                            }
+                        } else if let ValType::AssignedConstant(_, r) = e {
+                            if r == F::ZERO {
+                                return None;
+                            }
+                        }
+                        Some(e)
+                    })
+                    .collect();
+                *dims = v.dims().to_vec();
+            }
+            ValTensor::Instance { .. } => {}
         }
     }
 
     /// gets constants
-    pub fn get_const_indices(&self) -> Result<Vec<usize>, TensorError> {
+    pub fn get_const_zero_indices(&self) -> Vec<usize> {
         match self {
-            ValTensor::Value { inner: v, .. } => {
-                let mut indices = vec![];
-                for (i, e) in v.iter().enumerate() {
-                    if let ValType::Constant(_) = e {
-                        indices.push(i);
-                    } else if let ValType::AssignedConstant(_, _) = e {
-                        indices.push(i);
+            ValTensor::Value { inner: v, .. } => v
+                .par_iter()
+                .enumerate()
+                .filter_map(|(i, e)| {
+                    if let ValType::Constant(r) = e {
+                        if *r == F::ZERO {
+                            return Some(i);
+                        }
+                    } else if let ValType::AssignedConstant(_, r) = e {
+                        if *r == F::ZERO {
+                            return Some(i);
+                        }
                     }
-                }
-                Ok(indices)
-            }
-            ValTensor::Instance { .. } => Ok(vec![]),
+                    None
+                })
+                .collect(),
+            ValTensor::Instance { .. } => vec![],
+        }
+    }
+
+    /// gets constants
+    pub fn get_const_indices(&self) -> Vec<usize> {
+        match self {
+            ValTensor::Value { inner: v, .. } => v
+                .par_iter()
+                .enumerate()
+                .filter_map(|(i, e)| {
+                    if let ValType::Constant(_) = e {
+                        Some(i)
+                    } else if let ValType::AssignedConstant(_, _) = e {
+                        Some(i)
+                    } else {
+                        None
+                    }
+                })
+                .collect(),
+            ValTensor::Instance { .. } => vec![],
         }
     }
 
@@ -952,25 +1104,22 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
     }
     /// A [String] representation of the [ValTensor] for display, for example in showing intermediate values in a computational graph.
     pub fn show(&self) -> String {
-        match self.clone() {
-            ValTensor::Value {
-                inner: v, dims: _, ..
-            } => {
-                let r: Tensor<i32> = v.map(|x| x.into());
-                if r.len() > 10 {
-                    let start = r[..5].to_vec();
-                    let end = r[r.len() - 5..].to_vec();
-                    // print the two split by ... in the middle
-                    format!(
-                        "[{} ... {}]",
-                        start.iter().map(|x| format!("{}", x)).join(", "),
-                        end.iter().map(|x| format!("{}", x)).join(", ")
-                    )
-                } else {
-                    format!("{:?}", r)
-                }
-            }
-            _ => "ValTensor not PrevAssigned".into(),
+        let r = match self.int_evals() {
+            Ok(v) => v,
+            Err(_) => return "ValTensor not PrevAssigned".into(),
+        };
+
+        if r.len() > 10 {
+            let start = r[..5].to_vec();
+            let end = r[r.len() - 5..].to_vec();
+            // print the two split by ... in the middle
+            format!(
+                "[{} ... {}]",
+                start.iter().map(|x| format!("{}", x)).join(", "),
+                end.iter().map(|x| format!("{}", x)).join(", ")
+            )
+        } else {
+            format!("{:?}", r)
         }
     }
 }

src/tensor/var.rs

@@ -319,7 +319,7 @@ impl VarTensor {
         region: &mut Region<F>,
         offset: usize,
         values: &ValTensor<F>,
-        omissions: &HashSet<&usize>,
+        omissions: &HashSet<usize>,
         constants: &mut ConstantsMap<F>,
     ) -> Result<ValTensor<F>, halo2_proofs::plonk::Error> {
         let mut assigned_coord = 0;
@@ -368,7 +368,7 @@ impl VarTensor {
                             .sum::<usize>();
                     let dims = &dims[*idx];
                     // this should never ever fail
-                    let t: Tensor<i32> = Tensor::new(None, dims).unwrap();
+                    let t: Tensor<IntegerRep> = Tensor::new(None, dims).unwrap();
                     Ok(t.enum_map(|coord, _| {
                         let (x, y, z) = self.cartesian_coord(offset + coord);
                         region.assign_advice_from_instance(
@@ -497,7 +497,7 @@ impl VarTensor {
                     let (x, y, z) = self.cartesian_coord(offset + coord * step);
                     if matches!(check_mode, CheckMode::SAFE) && coord > 0 && z == 0 && y == 0 {
                         // assert that duplication occurred correctly
-                        assert_eq!(Into::<i32>::into(k.clone()), Into::<i32>::into(v[coord - 1].clone()));
+                        assert_eq!(Into::<IntegerRep>::into(k.clone()), Into::<IntegerRep>::into(v[coord - 1].clone()));
                     };
 
                     let cell = self.assign_value(region, offset, k.clone(), coord * step, constants)?;
@@ -533,13 +533,14 @@ impl VarTensor {
                 if matches!(check_mode, CheckMode::SAFE) {
                      // during key generation this will be 0 so we use this as a flag to check
                      // TODO: this isn't very safe and would be better to get the phase directly
-                    let is_assigned = !Into::<Tensor<i32>>::into(res.clone().get_inner().unwrap())
+                    let res_evals = res.int_evals().unwrap();
+                    let is_assigned = res_evals
                     .iter()
                     .all(|&x| x == 0);
-                    if is_assigned {
+                    if !is_assigned {
                         assert_eq!(
-                            Into::<Tensor<i32>>::into(values.get_inner().unwrap()),
-                            Into::<Tensor<i32>>::into(res.get_inner().unwrap())
+                           values.int_evals().unwrap(),
+                           res_evals
                     )};
                 }
 

src/wasm.rs

@@ -1,41 +1,52 @@
-use crate::circuit::modules::polycommit::PolyCommitChip;
-use crate::circuit::modules::poseidon::spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH};
-use crate::circuit::modules::poseidon::PoseidonChip;
-use crate::circuit::modules::Module;
-use crate::fieldutils::felt_to_i64;
-use crate::fieldutils::i64_to_felt;
-use crate::graph::modules::POSEIDON_LEN_GRAPH;
-use crate::graph::quantize_float;
-use crate::graph::scale_to_multiplier;
-use crate::graph::{GraphCircuit, GraphSettings};
-use crate::pfsys::create_proof_circuit;
-use crate::pfsys::evm::aggregation_kzg::AggregationCircuit;
-use crate::pfsys::evm::aggregation_kzg::PoseidonTranscript;
-use crate::pfsys::verify_proof_circuit;
-use crate::pfsys::TranscriptType;
-use crate::tensor::TensorType;
-use crate::CheckMode;
-use crate::Commitments;
+use crate::{
+    circuit::{
+        modules::{
+            polycommit::PolyCommitChip,
+            poseidon::{
+                spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH},
+                PoseidonChip,
+            },
+            Module,
+        },
+        region::RegionSettings,
+    },
+    fieldutils::{felt_to_integer_rep, integer_rep_to_felt},
+    graph::{
+        modules::POSEIDON_LEN_GRAPH, quantize_float, scale_to_multiplier, GraphCircuit,
+        GraphSettings,
+    },
+    pfsys::{
+        create_proof_circuit,
+        evm::aggregation_kzg::{AggregationCircuit, PoseidonTranscript},
+        verify_proof_circuit, TranscriptType,
+    },
+    tensor::TensorType,
+    CheckMode, Commitments,
+};
 use console_error_panic_hook;
-use halo2_proofs::plonk::*;
-use halo2_proofs::poly::commitment::{CommitmentScheme, ParamsProver};
-use halo2_proofs::poly::ipa::multiopen::{ProverIPA, VerifierIPA};
-use halo2_proofs::poly::ipa::{
-    commitment::{IPACommitmentScheme, ParamsIPA},
-    strategy::SingleStrategy as IPASingleStrategy,
+use halo2_proofs::{
+    plonk::*,
+    poly::{
+        commitment::{CommitmentScheme, ParamsProver},
+        ipa::{
+            commitment::{IPACommitmentScheme, ParamsIPA},
+            multiopen::{ProverIPA, VerifierIPA},
+            strategy::SingleStrategy as IPASingleStrategy,
+        },
+        kzg::{
+            commitment::{KZGCommitmentScheme, ParamsKZG},
+            multiopen::{ProverSHPLONK, VerifierSHPLONK},
+            strategy::SingleStrategy as KZGSingleStrategy,
+        },
+        VerificationStrategy,
+    },
 };
-use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
-use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
-use halo2_proofs::poly::kzg::{
-    commitment::{KZGCommitmentScheme, ParamsKZG},
-    strategy::SingleStrategy as KZGSingleStrategy,
-};
-use halo2_proofs::poly::VerificationStrategy;
 use halo2_solidity_verifier::encode_calldata;
-use halo2curves::bn256::{Bn256, Fr, G1Affine};
-use halo2curves::ff::{FromUniformBytes, PrimeField};
-use snark_verifier::loader::native::NativeLoader;
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
+use halo2curves::{
+    bn256::{Bn256, Fr, G1Affine},
+    ff::{FromUniformBytes, PrimeField},
+};
+use snark_verifier::{loader::native::NativeLoader, system::halo2::transcript::evm::EvmTranscript};
 use std::str::FromStr;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_console_logger::DEFAULT_LOGGER;
@@ -113,7 +124,7 @@ pub fn feltToInt(
     let felt: Fr = serde_json::from_slice(&array[..])
         .map_err(|e| JsError::new(&format!("Failed to deserialize field element: {}", e)))?;
     Ok(wasm_bindgen::Clamped(
-        serde_json::to_vec(&felt_to_i64(felt))
+        serde_json::to_vec(&felt_to_integer_rep(felt))
             .map_err(|e| JsError::new(&format!("Failed to serialize integer: {}", e)))?,
     ))
 }
@@ -127,7 +138,7 @@ pub fn feltToFloat(
 ) -> Result<f64, JsError> {
     let felt: Fr = serde_json::from_slice(&array[..])
         .map_err(|e| JsError::new(&format!("Failed to deserialize field element: {}", e)))?;
-    let int_rep = felt_to_i64(felt);
+    let int_rep = felt_to_integer_rep(felt);
     let multiplier = scale_to_multiplier(scale);
     Ok(int_rep as f64 / multiplier)
 }
@@ -141,7 +152,7 @@ pub fn floatToFelt(
 ) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
     let int_rep =
         quantize_float(&input, 0.0, scale).map_err(|e| JsError::new(&format!("{}", e)))?;
-    let felt = i64_to_felt(int_rep);
+    let felt = integer_rep_to_felt(int_rep);
     let vec = crate::pfsys::field_to_string::<halo2curves::bn256::Fr>(&felt);
     Ok(wasm_bindgen::Clamped(serde_json::to_vec(&vec).map_err(
         |e| JsError::new(&format!("Failed to serialize a float to felt{}", e)),
@@ -275,7 +286,15 @@ pub fn genWitness(
         .map_err(|e| JsError::new(&format!("{}", e)))?;
 
     let witness = circuit
-        .forward::<KZGCommitmentScheme<Bn256>>(&mut input, None, None, false, false)
+        .forward::<KZGCommitmentScheme<Bn256>>(
+            &mut input,
+            None,
+            None,
+            RegionSettings::all_true(
+                circuit.settings().run_args.decomp_base,
+                circuit.settings().run_args.decomp_legs,
+            ),
+        )
         .map_err(|e| JsError::new(&format!("{}", e)))?;
 
     serde_json::to_vec(&witness)

tests/integration_tests.rs

@@ -3,15 +3,19 @@
 mod native_tests {
 
     use ezkl::circuit::Tolerance;
-    use ezkl::fieldutils::{felt_to_i64, i64_to_felt};
+    use ezkl::fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep};
     // use ezkl::circuit::table::RESERVED_BLINDING_ROWS_PAD;
     use ezkl::graph::input::{FileSource, FileSourceInner, GraphData};
     use ezkl::graph::{DataSource, GraphSettings, GraphWitness};
+    use ezkl::pfsys::Snark;
     use ezkl::Commitments;
+    use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+    use halo2curves::bn256::Bn256;
     use lazy_static::lazy_static;
     use rand::Rng;
     use std::env::var;
     use std::io::{Read, Write};
+    use std::path::PathBuf;
     use std::process::{Child, Command};
     use std::sync::Once;
     static COMPILE: Once = Once::new();
@@ -183,12 +187,13 @@ mod native_tests {
 
     const PF_FAILURE_AGGR: &str = "examples/test_failure_aggr_proof.json";
 
-    const LARGE_TESTS: [&str; 5] = [
+    const LARGE_TESTS: [&str; 6] = [
         "self_attention",
         "nanoGPT",
         "multihead_attention",
         "mobilenet",
         "mnist_gan",
+        "smallworm",
     ];
 
     const ACCURACY_CAL_TESTS: [&str; 6] = [
@@ -200,7 +205,7 @@ mod native_tests {
         "1l_tiny_div",
     ];
 
-    const TESTS: [&str; 93] = [
+    const TESTS: [&str; 94] = [
         "1l_mlp", //0
         "1l_slice",
         "1l_concat",
@@ -240,8 +245,8 @@ mod native_tests {
         "1l_conv_transpose",
         "1l_upsample",
         "1l_identity", //35
-        "idolmodel",
-        "trig",
+        "idolmodel",   // too big evm
+        "trig",        // too big evm
         "prelu_gmm",
         "lstm",
         "rnn", //40
@@ -298,6 +303,7 @@ mod native_tests {
         "1l_lppool",
         "lstm_large",  // 91
         "lstm_medium", // 92
+        "lenet_5",     // 93
     ];
 
     const WASM_TESTS: [&str; 46] = [
@@ -536,7 +542,7 @@ mod native_tests {
             }
         });
 
-            seq!(N in 0..=92 {
+            seq!(N in 0..=93 {
 
             #(#[test_case(TESTS[N])])*
             #[ignore]
@@ -644,6 +650,15 @@ mod native_tests {
                 test_dir.close().unwrap();
             }
 
+            #(#[test_case(TESTS[N])])*
+            fn mock_hashed_params_public_inputs_(test: &str) {
+                crate::native_tests::init_binary();
+                let test_dir = TempDir::new(test).unwrap();
+                let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
+                mock(path, test.to_string(), "public", "hashed", "private", 1, "resources", None, 0.0);
+                test_dir.close().unwrap();
+            }
+
             #(#[test_case(TESTS[N])])*
             fn mock_fixed_inputs_(test: &str) {
                 crate::native_tests::init_binary();
@@ -940,7 +955,7 @@ mod native_tests {
 
             });
 
-            seq!(N in 0..=4 {
+            seq!(N in 0..=5 {
 
             #(#[test_case(LARGE_TESTS[N])])*
             #[ignore]
@@ -972,16 +987,26 @@ mod native_tests {
         mod tests_evm {
             use seq_macro::seq;
             use crate::native_tests::TESTS_EVM;
+            use crate::native_tests::TESTS;
             use crate::native_tests::TESTS_EVM_AGGR;
             use test_case::test_case;
             use crate::native_tests::kzg_evm_prove_and_verify;
-            use crate::native_tests::kzg_evm_prove_and_verify_render_seperately;
+            use crate::native_tests::kzg_evm_prove_and_verify_reusable_verifier;
 
             use crate::native_tests::kzg_evm_on_chain_input_prove_and_verify;
             use crate::native_tests::kzg_evm_aggr_prove_and_verify;
             use tempdir::TempDir;
             use crate::native_tests::Hardfork;
             use crate::native_tests::run_js_tests;
+            use ezkl::logger::init_logger;
+            use crate::native_tests::lazy_static;
+
+            // Global variables to store verifier hashes and identical verifiers
+            lazy_static! {
+                // create a new variable of type
+                static ref REUSABLE_VERIFIER_ADDR: std::sync::Mutex<Option<String>> = std::sync::Mutex::new(None);
+            }
+
 
             /// Currently only on chain inputs that return a non-negative value are supported.
             const TESTS_ON_CHAIN_INPUT: [&str; 17] = [
@@ -1093,6 +1118,70 @@ mod native_tests {
 
             });
 
+            seq!(N in 0..=93 {
+                #(#[test_case(TESTS[N])])*
+                fn kzg_evm_prove_and_verify_reusable_verifier_(test: &str) {
+                    crate::native_tests::init_binary();
+                    let test_dir = TempDir::new(test).unwrap();
+                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
+                    let _anvil_child = crate::native_tests::start_anvil(false, Hardfork::Latest);
+                    init_logger();
+                    log::error!("Running kzg_evm_prove_and_verify_reusable_verifier_ for test: {}", test);
+                    // default vis
+                    let reusable_verifier_address: String = kzg_evm_prove_and_verify_reusable_verifier(2, path, test.to_string(), "private", "private", "public", &mut REUSABLE_VERIFIER_ADDR.lock().unwrap(), false);
+                    // public/public vis
+                    let reusable_verifier_address: String = kzg_evm_prove_and_verify_reusable_verifier(2, path, test.to_string(), "public", "private", "public", &mut Some(reusable_verifier_address), false);
+                    // hashed input
+                    let reusable_verifier_address: String = kzg_evm_prove_and_verify_reusable_verifier(2, path, test.to_string(), "hashed", "private", "public", &mut Some(reusable_verifier_address), false);
+
+                    match REUSABLE_VERIFIER_ADDR.try_lock() {
+                        Ok(mut addr) => {
+                            *addr = Some(reusable_verifier_address.clone());
+                            log::error!("Reusing the same verifeir deployed at address: {}", reusable_verifier_address);
+                        }
+                        Err(_) => {
+                            log::error!("Failed to acquire lock on REUSABLE_VERIFIER_ADDR");
+                        }
+                    }
+
+                    test_dir.close().unwrap();
+
+                }
+
+                #(#[test_case(TESTS[N])])*
+                fn kzg_evm_prove_and_verify_reusable_verifier_with_overflow_(test: &str) {
+                    // verifier too big to fit on chain with overflow calibration target
+                    if test == "1l_eltwise_div" || test == "lenet_5" || test == "ltsf" || test == "lstm_large" {
+                        return;
+                    }
+                    crate::native_tests::init_binary();
+                    let test_dir = TempDir::new(test).unwrap();
+                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
+                    let _anvil_child = crate::native_tests::start_anvil(false, Hardfork::Latest);
+                    init_logger();
+                    log::error!("Running kzg_evm_prove_and_verify_reusable_verifier_with_overflow_ for test: {}", test);
+                    // default vis
+                    let reusable_verifier_address: String = kzg_evm_prove_and_verify_reusable_verifier(2, path, test.to_string(), "private", "private", "public", &mut REUSABLE_VERIFIER_ADDR.lock().unwrap(), true);
+                    // public/public vis
+                    let reusable_verifier_address: String = kzg_evm_prove_and_verify_reusable_verifier(2, path, test.to_string(), "public", "private", "public", &mut Some(reusable_verifier_address), true);
+                    // hashed input
+                    let reusable_verifier_address: String = kzg_evm_prove_and_verify_reusable_verifier(2, path, test.to_string(), "hashed", "private", "public", &mut Some(reusable_verifier_address), true);
+
+                    match REUSABLE_VERIFIER_ADDR.try_lock() {
+                        Ok(mut addr) => {
+                            *addr = Some(reusable_verifier_address.clone());
+                            log::error!("Reusing the same verifeir deployed at address: {}", reusable_verifier_address);
+                        }
+                        Err(_) => {
+                            log::error!("Failed to acquire lock on REUSABLE_VERIFIER_ADDR");
+                        }
+                    }
+
+                    test_dir.close().unwrap();
+
+                }
+            });
+
 
             seq!(N in 0..=22 {
 
@@ -1109,19 +1198,6 @@ mod native_tests {
 
                 }
 
-                #(#[test_case(TESTS_EVM[N])])*
-                fn kzg_evm_prove_and_verify_render_seperately_(test: &str) {
-                    crate::native_tests::init_binary();
-                    let test_dir = TempDir::new(test).unwrap();
-                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                    let _anvil_child = crate::native_tests::start_anvil(false, Hardfork::Latest);
-                    kzg_evm_prove_and_verify_render_seperately(2, path, test.to_string(), "private", "private", "public");
-                    #[cfg(not(feature = "icicle"))]
-                    run_js_tests(path, test.to_string(), "testBrowserEvmVerify", true);
-                    test_dir.close().unwrap();
-
-                }
-
 
                 #(#[test_case(TESTS_EVM[N])])*
                 fn kzg_evm_hashed_input_prove_and_verify_(test: &str) {
@@ -1411,10 +1487,10 @@ mod native_tests {
                             let perturbation = if v == &halo2curves::bn256::Fr::zero() {
                                 halo2curves::bn256::Fr::zero()
                             } else {
-                                i64_to_felt(
-                                    (felt_to_i64(*v) as f32
+                                integer_rep_to_felt(
+                                    (felt_to_integer_rep(*v) as f32
                                         * (rand::thread_rng().gen_range(-0.01..0.01) * tolerance))
-                                        as i64,
+                                        as IntegerRep,
                                 )
                             };
 
@@ -1434,10 +1510,10 @@ mod native_tests {
                             let perturbation = if v == &halo2curves::bn256::Fr::zero() {
                                 halo2curves::bn256::Fr::from(2)
                             } else {
-                                i64_to_felt(
-                                    (felt_to_i64(*v) as f32
+                                integer_rep_to_felt(
+                                    (felt_to_integer_rep(*v) as f32
                                         * (rand::thread_rng().gen_range(0.02..0.1) * tolerance))
-                                        as i64,
+                                        as IntegerRep,
                                 )
                             };
                             *v + perturbation
@@ -1872,7 +1948,7 @@ mod native_tests {
 
         // deploy the verifier
         let args = vec![
-            "deploy-evm-verifier",
+            "deploy-evm",
             rpc_arg.as_str(),
             addr_path_arg.as_str(),
             "--sol-code-path",
@@ -2103,11 +2179,7 @@ mod native_tests {
         assert!(status.success());
 
         // deploy the verifier
-        let mut args = vec![
-            "deploy-evm-verifier",
-            rpc_arg.as_str(),
-            addr_path_arg.as_str(),
-        ];
+        let mut args = vec!["deploy-evm", rpc_arg.as_str(), addr_path_arg.as_str()];
 
         args.push("--sol-code-path");
         args.push(sol_arg.as_str());
@@ -2149,14 +2221,16 @@ mod native_tests {
     }
 
     // prove-serialize-verify, the usual full path
-    fn kzg_evm_prove_and_verify_render_seperately(
+    fn kzg_evm_prove_and_verify_reusable_verifier(
         num_inner_columns: usize,
         test_dir: &str,
         example_name: String,
         input_visibility: &str,
         param_visibility: &str,
         output_visibility: &str,
-    ) {
+        reusable_verifier_address: &mut Option<String>,
+        overflow: bool,
+    ) -> String {
         let anvil_url = ANVIL_URL.as_str();
 
         prove_and_verify(
@@ -2168,7 +2242,7 @@ mod native_tests {
             output_visibility,
             num_inner_columns,
             None,
-            false,
+            overflow,
             "single",
             Commitments::KZG,
             2,
@@ -2183,27 +2257,58 @@ mod native_tests {
         let settings_arg = format!("--settings-path={}", settings_path);
         let sol_arg = format!("--sol-code-path={}/{}/kzg.sol", test_dir, example_name);
 
-        // create the verifier
-        let args = vec![
-            "create-evm-verifier",
-            "--vk-path",
-            &vk_arg,
-            &settings_arg,
-            &sol_arg,
-            "--render-vk-seperately",
-        ];
+        // if the reusable verifier address is not set, create the verifier
+        let deployed_addr_arg = match reusable_verifier_address {
+            Some(addr) => addr.clone(),
+            None => {
+                // create the reusable verifier
+                let args = vec![
+                    "create-evm-verifier",
+                    "--vk-path",
+                    &vk_arg,
+                    &settings_arg,
+                    &sol_arg,
+                    "--reusable",
+                ];
 
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
-            .args(&args)
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
+                let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                    .args(&args)
+                    .status()
+                    .expect("failed to execute process");
+                assert!(status.success());
+
+                // deploy the verifier
+                let args = vec![
+                    "deploy-evm",
+                    rpc_arg.as_str(),
+                    addr_path_arg.as_str(),
+                    sol_arg.as_str(),
+                    "-C=verifier/reusable",
+                ];
+
+                let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                    .args(&args)
+                    .status()
+                    .expect("failed to execute process");
+                assert!(status.success());
+
+                // read in the address
+                let addr =
+                    std::fs::read_to_string(format!("{}/{}/addr.txt", test_dir, example_name))
+                        .expect("failed to read address file");
+
+                let deployed_addr_arg = format!("--addr-verifier={}", addr);
+                // set the reusable verifier address
+                *reusable_verifier_address = Some(addr);
+                deployed_addr_arg
+            }
+        };
 
         let addr_path_arg_vk = format!("--addr-path={}/{}/addr_vk.txt", test_dir, example_name);
-        let sol_arg_vk = format!("--sol-code-path={}/{}/vk.sol", test_dir, example_name);
+        let sol_arg_vk: String = format!("--sol-code-path={}/{}/vk.sol", test_dir, example_name);
         // create the verifier
         let args = vec![
-            "create-evm-vk",
+            "create-evm-vka",
             "--vk-path",
             &vk_arg,
             &settings_arg,
@@ -2216,32 +2321,13 @@ mod native_tests {
             .expect("failed to execute process");
         assert!(status.success());
 
-        // deploy the verifier
+        // deploy the vka
         let args = vec![
-            "deploy-evm-verifier",
-            rpc_arg.as_str(),
-            addr_path_arg.as_str(),
-            sol_arg.as_str(),
-        ];
-
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
-            .args(&args)
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
-
-        // read in the address
-        let addr = std::fs::read_to_string(format!("{}/{}/addr.txt", test_dir, example_name))
-            .expect("failed to read address file");
-
-        let deployed_addr_arg = format!("--addr-verifier={}", addr);
-
-        // deploy the vk
-        let args = vec![
-            "deploy-evm-vk",
+            "deploy-evm",
             rpc_arg.as_str(),
             addr_path_arg_vk.as_str(),
             sol_arg_vk.as_str(),
+            "-C=vka",
         ];
 
         let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
@@ -2271,7 +2357,7 @@ mod native_tests {
 
         // now verify the proof
         let pf_arg = format!("{}/{}/proof.pf", test_dir, example_name);
-        let mut args = vec![
+        let args = vec![
             "verify-evm",
             "--proof-path",
             pf_arg.as_str(),
@@ -2285,13 +2371,52 @@ mod native_tests {
             .status()
             .expect("failed to execute process");
         assert!(status.success());
-        // As sanity check, add example that should fail.
-        args[2] = PF_FAILURE;
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
-            .args(args)
-            .status()
-            .expect("failed to execute process");
-        assert!(!status.success());
+        // Read the original proof file
+        let original_proof_data: ezkl::pfsys::Snark<
+            halo2curves::bn256::Fr,
+            halo2curves::bn256::G1Affine,
+        > = Snark::load::<KZGCommitmentScheme<Bn256>>(&PathBuf::from(format!(
+            "{}/{}/proof.pf",
+            test_dir, example_name
+        )))
+        .expect("Failed to read proof file");
+
+        for i in 0..1 {
+            // Create a copy of the original proof data
+            let mut modified_proof_data = original_proof_data.clone();
+
+            // Flip a random bit
+            let random_byte = rand::thread_rng().gen_range(0..modified_proof_data.proof.len());
+            let random_bit = rand::thread_rng().gen_range(0..8);
+            modified_proof_data.proof[random_byte] ^= 1 << random_bit;
+
+            // Write the modified proof to a new file
+            let modified_pf_arg = format!("{}/{}/modified_proof_{}.pf", test_dir, example_name, i);
+            modified_proof_data
+                .save(&PathBuf::from(modified_pf_arg.clone()))
+                .expect("Failed to save modified proof file");
+
+            // Verify the modified proof (should fail)
+            let mut args_mod = args.clone();
+            args_mod[2] = &modified_pf_arg;
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                .args(&args_mod)
+                .status()
+                .expect("failed to execute process");
+
+            if status.success() {
+                log::error!("Verification unexpectedly succeeded for modified proof {}. Flipped bit {} in byte {}", i, random_bit, random_byte);
+            }
+
+            assert!(
+                !status.success(),
+                "Modified proof {} should have failed verification",
+                i
+            );
+        }
+
+        // Returned deploy_addr_arg for reusable verifier
+        deployed_addr_arg
     }
 
     // run js browser evm verify tests for a given example
@@ -2493,7 +2618,7 @@ mod native_tests {
 
         // deploy the verifier
         let mut args = vec![
-            "deploy-evm-verifier",
+            "deploy-evm",
             rpc_arg.as_str(),
             addr_path_verifier_arg.as_str(),
         ];

tests/py_integration_tests.rs

@@ -11,7 +11,7 @@ mod py_tests {
     static ENV_SETUP: Once = Once::new();
     static DOWNLOAD_VOICE_DATA: Once = Once::new();
 
-    //Sure to run this once
+    // Sure to run this once
 
     lazy_static! {
         static ref CARGO_TARGET_DIR: String =
@@ -123,7 +123,8 @@ mod py_tests {
         }
     }
 
-    const TESTS: [&str; 33] = [
+    const TESTS: [&str; 34] = [
+        "ezkl_demo_batch.ipynb",
         "proof_splitting.ipynb", // 0
         "variance.ipynb",
         "mnist_gan.ipynb",
@@ -201,6 +202,18 @@ mod py_tests {
                 anvil_child.kill().unwrap();
             }
 
+            #[test]
+            fn reusable_verifier_notebook_() {
+                crate::py_tests::init_binary();
+                let mut anvil_child = crate::py_tests::start_anvil(false);
+                let test_dir: TempDir = TempDir::new("reusable_verifier").unwrap();
+                let path = test_dir.path().to_str().unwrap();
+                crate::py_tests::mv_test_(path, "reusable_verifier.ipynb");
+                run_notebook(path, "reusable_verifier.ipynb");
+                test_dir.close().unwrap();
+                anvil_child.kill().unwrap();
+            }
+
             #[test]
             fn postgres_notebook_() {
                 crate::py_tests::init_binary();

tests/python/binding_tests.py

@@ -23,7 +23,7 @@ examples_path = os.path.abspath(
 
 srs_path = os.path.join(folder_path, 'kzg_test.params')
 params_k17_path = os.path.join(folder_path, 'kzg_test_k17.params')
-params_k20_path = os.path.join(folder_path, 'kzg_test_k20.params')
+params_k21_path = os.path.join(folder_path, 'kzg_test_k21.params')
 anvil_url = "http://localhost:3030"
 
 
@@ -104,8 +104,8 @@ def test_gen_srs():
     ezkl.gen_srs(params_k17_path, 17)
     assert os.path.isfile(params_k17_path)
 
-    ezkl.gen_srs(params_k20_path, 20)
-    assert os.path.isfile(params_k20_path)
+    ezkl.gen_srs(params_k21_path, 21)
+    assert os.path.isfile(params_k21_path)
 
 
 
@@ -423,6 +423,76 @@ async def test_create_evm_verifier():
     assert res == True
     assert os.path.isfile(sol_code_path)
 
+async def test_create_evm_verifier_separate_vk():
+    """
+    Create EVM a verifier with solidity code and separate vk
+    In order to run this test you will need to install solc in your environment
+    """
+    vk_path = os.path.join(folder_path, 'test_evm.vk')
+    settings_path = os.path.join(folder_path, 'settings.json')
+    sol_code_path = os.path.join(folder_path, 'test_separate.sol')
+    vk_code_path = os.path.join(folder_path, 'test_vk.sol')
+    abi_path = os.path.join(folder_path, 'test_separate.abi')
+    abi_vk_path = os.path.join(folder_path, 'test_vk_separate.abi')
+    proof_path = os.path.join(folder_path, 'test_evm.pf')
+    calldata_path = os.path.join(folder_path, 'calldata.bytes')
+
+    # # res is now a vector of bytes
+    # res = ezkl.encode_evm_calldata(proof_path, calldata_path)
+
+    # assert os.path.isfile(calldata_path)
+    # assert len(res) > 0
+
+
+    res = await ezkl.create_evm_verifier(
+        vk_path,
+        settings_path,
+        sol_code_path,
+        abi_path,
+        srs_path=srs_path,
+        reusable=True
+    )
+
+    res = await ezkl.create_evm_vka(
+        vk_path,
+        settings_path,
+        vk_code_path,
+        abi_vk_path,
+        srs_path=srs_path,
+    )
+
+    assert res == True
+    assert os.path.isfile(sol_code_path)
+
+
+async def test_deploy_evm_reusable_and_vka():
+    """
+    Test deployment of the reusable verifier smart contract + vka
+    In order to run this you will need to install solc in your environment
+    """
+    addr_path_verifier = os.path.join(folder_path, 'address_separate.json')
+    addr_path_vk = os.path.join(folder_path, 'address_vk.json')
+    sol_code_path = os.path.join(folder_path, 'test_separate.sol')
+    vk_code_path = os.path.join(folder_path, 'test_vk.sol')
+
+    # TODO: without optimization there will be out of gas errors
+    # sol_code_path = os.path.join(folder_path, 'test.sol')
+
+    res = await ezkl.deploy_evm(
+        addr_path_verifier,
+        sol_code_path,
+        anvil_url,
+        "verifier/reusable",
+    )
+
+    res = await ezkl.deploy_evm(
+        addr_path_vk,
+        vk_code_path,
+        anvil_url,
+        "vka",
+    )
+
+    assert res == True
 
 async def test_deploy_evm():
     """
@@ -438,7 +508,7 @@ async def test_deploy_evm():
     res = await ezkl.deploy_evm(
         addr_path,
         sol_code_path,
-        rpc_url=anvil_url,
+        anvil_url,
     )
 
     assert res == True
@@ -503,6 +573,47 @@ async def test_verify_evm():
 
     assert res == True
 
+async def test_verify_evm_separate_vk():
+    """
+    Verifies an evm proof
+    In order to run this you will need to install solc in your environment
+    """
+    proof_path = os.path.join(folder_path, 'test_evm.pf')
+    addr_path_verifier = os.path.join(folder_path, 'address_separate.json')
+    addr_path_vk = os.path.join(folder_path, 'address_vk.json')
+    proof_path = os.path.join(folder_path, 'test_evm.pf')
+    calldata_path = os.path.join(folder_path, 'calldata_separate.bytes')
+
+    with open(addr_path_verifier, 'r') as file:
+        addr_verifier = file.read().rstrip()
+
+    print(addr_verifier)
+
+    with open(addr_path_vk, 'r') as file:
+        addr_vk = file.read().rstrip()
+
+    print(addr_vk)
+
+    # res is now a vector of bytes
+    res = ezkl.encode_evm_calldata(proof_path, calldata_path, addr_vk=addr_vk)
+
+    assert os.path.isfile(calldata_path)
+    assert len(res) > 0
+
+    # TODO: without optimization there will be out of gas errors
+    # sol_code_path = os.path.join(folder_path, 'test.sol')
+
+    res = await ezkl.verify_evm(
+        addr_verifier,
+        proof_path,
+        rpc_url=anvil_url,
+        addr_vk=addr_vk,
+        # sol_code_path
+        # optimizer_runs
+    )
+
+    assert res == True
+
 
 async def test_aggregate_and_verify_aggr():
     data_path = os.path.join(
@@ -568,7 +679,7 @@ async def test_aggregate_and_verify_aggr():
     )
 
     # mock aggregate
-    res = ezkl.mock_aggregate([proof_path], 20)
+    res = ezkl.mock_aggregate([proof_path], 21)
     assert res == True
 
     aggregate_proof_path = os.path.join(folder_path, 'aggr_1l_relu.pf')
@@ -579,8 +690,8 @@ async def test_aggregate_and_verify_aggr():
         [proof_path],
         aggregate_vk_path,
         aggregate_pk_path,
-        20,
-        srs_path=params_k20_path,
+        21,
+        srs_path=params_k21_path,
     )
 
     res = ezkl.gen_vk_from_pk_aggr(aggregate_pk_path, aggregate_vk_path)
@@ -592,9 +703,9 @@ async def test_aggregate_and_verify_aggr():
         aggregate_proof_path,
         aggregate_pk_path,
         "poseidon",
-        20,
+        21,
         "unsafe",
-        srs_path=params_k20_path,
+        srs_path=params_k21_path,
     )
 
     assert res == True
@@ -604,8 +715,8 @@ async def test_aggregate_and_verify_aggr():
     res = ezkl.verify_aggr(
         aggregate_proof_path,
         aggregate_vk_path,
-        20,
-        srs_path=params_k20_path,
+        21,
+        srs_path=params_k21_path,
     )
     assert res == True
 
@@ -684,8 +795,8 @@ async def test_evm_aggregate_and_verify_aggr():
         [proof_path],
         aggregate_vk_path,
         aggregate_pk_path,
-        20,
-        srs_path=params_k20_path,
+        21,
+        srs_path=params_k21_path,
     )
 
     res = ezkl.aggregate(
@@ -693,9 +804,9 @@ async def test_evm_aggregate_and_verify_aggr():
         aggregate_proof_path,
         aggregate_pk_path,
         "evm",
-        20,
+        21,
         "unsafe",
-        srs_path=params_k20_path,
+        srs_path=params_k21_path,
     )
 
     assert res == True
@@ -710,8 +821,8 @@ async def test_evm_aggregate_and_verify_aggr():
         aggregate_vk_path,
         sol_code_path,
         abi_path,
-        logrows=20,
-        srs_path=params_k20_path,
+        logrows=21,
+        srs_path=params_k21_path,
     )
 
     assert res == True
@@ -729,8 +840,8 @@ async def test_evm_aggregate_and_verify_aggr():
     res = ezkl.verify_aggr(
         aggregate_proof_path,
         aggregate_vk_path,
-        20,
-        srs_path=params_k20_path,
+        21,
+        srs_path=params_k21_path,
     )
     assert res == True
 
@@ -761,6 +872,7 @@ def get_examples():
         'accuracy',
         'linear_regression',
         "mnist_gan",
+        "smallworm",
     ]
     examples = []
     for subdir, _, _ in os.walk(os.path.join(examples_path, "onnx")):

tests/wasm.rs

@@ -16,14 +16,12 @@ mod wasm32 {
         srsValidation, u8_array_to_u128_le, verify, verifyAggr, vkValidation, witnessValidation,
     };
     use halo2_proofs::plonk::VerifyingKey;
-    use halo2_proofs::poly::commitment::CommitmentScheme;
     use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
     use halo2_proofs::poly::kzg::commitment::ParamsKZG;
     use halo2_solidity_verifier::encode_calldata;
     use halo2curves::bn256::Bn256;
     use halo2curves::bn256::{Fr, G1Affine};
     use snark_verifier::util::arithmetic::PrimeField;
-    use wasm_bindgen::JsError;
     #[cfg(feature = "web")]
     pub use wasm_bindgen_rayon::init_thread_pool;
     use wasm_bindgen_test::*;

tests/wasm/settings.json

@@ -8,7 +8,7 @@
         "param_scale": 0,
         "scale_rebase_multiplier": 10,
         "lookup_range": [
-            -2,
+            0,
             0
         ],
         "logrows": 6,
@@ -24,15 +24,18 @@
         "param_visibility": "Private",
         "div_rebasing": false,
         "rebase_frac_zero_constants": false,
-        "check_mode": "UNSAFE"
+        "check_mode": "UNSAFE",
+        "commitment": "KZG",
+        "decomp_base": 128,
+        "decomp_legs": 2
     },
-    "num_rows": 16,
+    "num_rows": 46,
+    "total_assignments": 92,
+    "total_const_size": 3,
     "total_dynamic_col_size": 0,
     "num_dynamic_lookups": 0,
     "num_shuffles": 0,
     "total_shuffle_col_size": 0,
-    "total_assignments": 32,
-    "total_const_size": 8,
     "model_instance_shapes": [
         [
             1,
@@ -54,12 +57,19 @@
             ]
         ]
     },
-    "required_lookups": [
-        "ReLU"
+    "required_lookups": [],
+    "required_range_checks": [
+        [
+            -1,
+            1
+        ],
+        [
+            0,
+            127
+        ]
     ],
-    "required_range_checks": [],
     "check_mode": "UNSAFE",
     "version": "0.0.0",
     "num_blinding_factors": null,
-    "timestamp": 1702474230544
+    "timestamp": 1726429587279
 }

tests/wasm/witness.json

@@ -1 +1 @@
-{"inputs":[["0200000000000000000000000000000000000000000000000000000000000000","0100000000000000000000000000000000000000000000000000000000000000","0100000000000000000000000000000000000000000000000000000000000000"]],"pretty_elements":{"rescaled_inputs":[["2","1","1"]],"inputs":[["0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000001"]],"processed_inputs":[],"processed_params":[],"processed_outputs":[],"rescaled_outputs":[["0","0","0","0"]],"outputs":[["0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000"]]},"outputs":[["0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000"]],"processed_inputs":null,"processed_params":null,"processed_outputs":null,"max_lookup_inputs":0,"min_lookup_inputs":-1,"max_range_size":0}
+{"inputs":[["0200000000000000000000000000000000000000000000000000000000000000","0100000000000000000000000000000000000000000000000000000000000000","0100000000000000000000000000000000000000000000000000000000000000"]],"pretty_elements":{"rescaled_inputs":[["2","1","1"]],"inputs":[["0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000001"]],"processed_inputs":[],"processed_params":[],"processed_outputs":[],"rescaled_outputs":[["0","0","0","0"]],"outputs":[["0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000"]]},"outputs":[["0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000"]],"processed_inputs":null,"processed_params":null,"processed_outputs":null,"max_lookup_inputs":0,"min_lookup_inputs":0,"max_range_size":127}