patch large mock

Update integration_tests.rs
Update layouts.rs
2026-01-13 08:17:57 -05:00 · 2025-02-03 16:08:24 +00:00 · 2025-02-03 12:31:14 +00:00 · 2025-02-03 09:03:46 +00:00 · 2025-02-03 09:00:57 +00:00 · 2025-02-02 21:26:57 +00:00
25 changed files with 457 additions and 379 deletions
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -20,6 +20,7 @@ env:

 jobs:
  fr-age-test:
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
    permissions:
      contents: read
    runs-on: large-self-hosted
@@ -32,8 +33,12 @@ jobs:
          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
+      - uses: baptiste0928/cargo-install@v1
+        with:
+          crate: cargo-nextest
+          locked: true
      - name: fr age Mock
-        run: cargo test --release --verbose tests::large_mock_::large_tests_6_expects -- --include-ignored
+        run: cargo nextest run --release --verbose tests::large_mock_::large_tests_6_expects -- --include-ignored

  build:
    permissions:
@@ -158,13 +163,13 @@ jobs:
      # - 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 --no-default-features --features ezkl -- --include-ignored
+        run: cargo nextest run --release lookup_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
      - name: Matmul overflow
-        run: RUST_LOG=debug cargo nextest run matmul_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
+        run: RUST_LOG=debug cargo nextest run --release matmul_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
      - name: Conv overflow
-        run: RUST_LOG=debug cargo nextest run conv_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
+        run: RUST_LOG=debug cargo nextest run --release conv_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
      - name: Conv + relu overflow
-        run: cargo nextest run  --release conv_relu_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
+        run: cargo nextest run --release conv_relu_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored

  ultra-overflow-tests:
    permissions:
@@ -195,13 +200,13 @@ jobs:
      # - 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 -- --include-ignored
+        run: cargo nextest run lookup_ultra_overflow --no-capture -- --include-ignored
      - name: Matmul overflow
        run: RUST_LOG=debug cargo nextest run matmul_col_ultra_overflow --no-capture -- --include-ignored
      - name: Conv overflow
-        run: RUST_LOG=debug cargo nextest run conv_col_ultra_overflow --no-capture -- --include-ignored
+        run: RUST_LOG=debug cargo nextest run --release conv_col_ultra_overflow --no-capture -- --include-ignored
      - name: Conv + relu overflow
-        run: cargo nextest run  --release conv_relu_col_ultra_overflow --no-capture -- --include-ignored
+        run: cargo nextest run --release conv_relu_col_ultra_overflow --no-capture -- --include-ignored

  model-serialization:
    permissions:
@@ -226,7 +231,7 @@ jobs:
  wasm32-tests:
    permissions:
      contents: read
-    runs-on: ubuntu-latest
+    runs-on: non-gpu
    steps:
      - uses: actions/checkout@v4
        with:
@@ -256,7 +261,6 @@ jobs:
    permissions:
      contents: read
    runs-on: non-gpu
-    needs: [build, library-tests, docs, python-tests, python-integration-tests]
    steps:
      - uses: actions/checkout@v4
        with:
@@ -271,53 +275,53 @@ jobs:
          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 bounded lookup log
-        run: cargo nextest run --release --verbose tests::mock_bounded_lookup_log --test-threads 32
-      - 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 16
-      - name: kzg inputs
-        run: cargo nextest run --release --verbose tests::mock_kzg_input_::t  --test-threads 32
-      - name: kzg params
-        run: cargo nextest run --release --verbose tests::mock_kzg_params_::t  --test-threads 32
-      - name: kzg outputs
-        run: cargo nextest run --release --verbose tests::mock_kzg_output_::t  --test-threads 32
-      - name: kzg inputs + params + outputs
-        run: cargo nextest run --release --verbose tests::mock_kzg_all_::t  --test-threads 32
-      - name: Mock fixed inputs
-        run: cargo nextest run --release --verbose tests::mock_fixed_inputs_ --test-threads 32
-      - name: Mock fixed outputs
-        run: cargo nextest run --release --verbose tests::mock_fixed_outputs --test-threads 32
-      - name: Mock accuracy calibration
-        run: cargo nextest run --release --verbose tests::mock_accuracy_cal_tests::a
-      - name: hashed inputs
-        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
-        run: cargo nextest run --release --verbose tests::mock_hashed_all_::t  --test-threads 32
-      - name: hashed inputs + fixed params
-        run: cargo nextest run --release --verbose tests::mock_hashed_output_fixed_params_::t  --test-threads 32
+      #   run: cargo nextest run --verbose tests::large_mock_::large_tests_5_expects -- --include-ignored
      - name: MNIST Gan Mock
-        run: cargo nextest run --release --verbose tests::large_mock_::large_tests_4_expects -- --include-ignored
+        run: cargo nextest run --verbose tests::large_mock_::large_tests_4_expects -- --include-ignored
      - name: NanoGPT Mock
-        run: cargo nextest run --release --verbose tests::large_mock_::large_tests_1_expects -- --include-ignored
+        run: cargo nextest run --verbose tests::large_mock_::large_tests_1_expects -- --include-ignored
      - name: Self Attention Mock
-        run: cargo nextest run --release --verbose tests::large_mock_::large_tests_0_expects -- --include-ignored
+        run: cargo nextest run --verbose tests::large_mock_::large_tests_0_expects -- --include-ignored
      - name: Multihead Attention Mock
-        run: cargo nextest run --release --verbose tests::large_mock_::large_tests_2_expects -- --include-ignored
+        run: cargo nextest run --verbose tests::large_mock_::large_tests_2_expects -- --include-ignored
      - name: public outputs
-        run: cargo nextest run --release --verbose tests::mock_public_outputs_ --test-threads 32
+        run: cargo nextest run --verbose tests::mock_public_outputs_ --test-threads 32
      - name: public inputs
-        run: cargo nextest run --release --verbose tests::mock_public_inputs_ --test-threads 32
+        run: cargo nextest run --verbose tests::mock_public_inputs_ --test-threads 32
      - name: fixed params
-        run: cargo nextest run --release --verbose tests::mock_fixed_params_ --test-threads 32
+        run: cargo nextest run --verbose tests::mock_fixed_params_ --test-threads 32
+      - name: public outputs and bounded lookup log
+        run: cargo nextest run --verbose tests::mock_bounded_lookup_log --test-threads 32
+      - name: public outputs and tolerance > 0
+        run: cargo nextest run --verbose tests::mock_tolerance_public_outputs_ --test-threads 32
+      - name: public outputs + batch size == 10
+        run: cargo nextest run --verbose tests::mock_large_batch_public_outputs_ --test-threads 16
+      - name: kzg inputs
+        run: cargo nextest run --verbose tests::mock_kzg_input_::t  --test-threads 32
+      - name: kzg params
+        run: cargo nextest run --verbose tests::mock_kzg_params_::t  --test-threads 32
+      - name: kzg outputs
+        run: cargo nextest run --verbose tests::mock_kzg_output_::t  --test-threads 32
+      - name: kzg inputs + params + outputs
+        run: cargo nextest run --verbose tests::mock_kzg_all_::t  --test-threads 32
+      - name: Mock fixed inputs
+        run: cargo nextest run --verbose tests::mock_fixed_inputs_ --test-threads 32
+      - name: Mock fixed outputs
+        run: cargo nextest run --verbose tests::mock_fixed_outputs --test-threads 32
+      - name: Mock accuracy calibration
+        run: cargo nextest run --verbose tests::mock_accuracy_cal_tests::a
+      - name: hashed inputs
+        run: cargo nextest run --verbose tests::mock_hashed_input_::t  --test-threads 32
+      - name: hashed params
+        run: cargo nextest run --verbose tests::mock_hashed_params_::t  --test-threads 32
+      - name: hashed params public inputs
+        run: cargo nextest run --verbose tests::mock_hashed_params_public_inputs_::t  --test-threads 32
+      - name: hashed outputs
+        run: cargo nextest run --verbose tests::mock_hashed_output_::t  --test-threads 32
+      - name: hashed inputs + params + outputs
+        run: cargo nextest run --verbose tests::mock_hashed_all_::t  --test-threads 32
+      - name: hashed inputs + fixed params
+        run: cargo nextest run --verbose tests::mock_hashed_output_fixed_params_::t  --test-threads 32

  prove-and-verify-evm-tests:
    permissions:
@@ -360,7 +364,7 @@ jobs:
          NODE_ENV: development
      - name: Build wasm package for nodejs target.
        run: |
-          wasm-pack build --release --target nodejs --out-dir ./in-browser-evm-verifier/nodejs . -- -Z build-std="panic_abort,std"
+          wasm-pack build --target nodejs --out-dir ./in-browser-evm-verifier/nodejs . -- -Z build-std="panic_abort,std"
      - name: Replace memory definition in nodejs
        run: |
          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" in-browser-evm-verifier/nodejs/ezkl.js
@@ -374,35 +378,35 @@ jobs:
      - name: Install Anvil
        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
+        run: cargo nextest run --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
+        run: cargo nextest run --verbose tests_evm::kzg_evm_kzg_all_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + kzg inputs)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_kzg_input_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_kzg_input_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + kzg params)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_kzg_params_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_kzg_params_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + on chain inputs)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_input_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + on chain outputs)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_output_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_output_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + on chain inputs & outputs)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_output_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_input_output_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + on chain inputs & kzg outputs + params)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_kzg_output_kzg_params_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_input_kzg_output_kzg_params_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + on chain outputs & kzg inputs + params)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_output_kzg_input_kzg_params_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_output_kzg_input_kzg_params_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + on chain all kzg)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_all_kzg_params_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_all_kzg_params_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + on chain inputs & outputs hashes)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_output_hashed_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_input_output_hashed_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + hashed inputs)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_hashed_input_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_hashed_input_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + hashed params)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_hashed_params_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_hashed_params_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + hashed outputs)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_hashed_output_prove_and_verify --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_hashed_output_prove_and_verify --test-threads 1

  # prove-and-verify-tests-metal:
  #   permissions:
@@ -436,7 +440,7 @@ jobs:
  #         crate: cargo-nextest
  #         locked: true
  #     - name: KZG prove and verify tests (public outputs)
-  #       run: cargo nextest run --release --features macos-metal --verbose tests::kzg_prove_and_verify_::t --no-capture
+  #       run: cargo nextest run --features macos-metal --verbose tests::kzg_prove_and_verify_::t --no-capture

  prove-and-verify-tests:
    permissions:
@@ -485,40 +489,40 @@ jobs:
          locked: true
      - name: Build wasm package for nodejs target.
        run: |
-          wasm-pack build --release --target nodejs --out-dir ./tests/wasm/nodejs . -- -Z build-std="panic_abort,std"
+          wasm-pack build --target nodejs --out-dir ./tests/wasm/nodejs . -- -Z build-std="panic_abort,std"
      - name: Replace memory definition in nodejs
        run: |
          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" tests/wasm/nodejs/ezkl.js
      - name: KZG prove and verify tests (public outputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_with_overflow_::w
      - 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_
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_
      - name: KZG prove and verify tests (hashed inputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_hashed_inputs_
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_with_overflow_hashed_inputs_
      - name: KZG prove and verify tests (public outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_tight_lookup_::t
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_tight_lookup_::t
      - name: IPA prove and verify tests
-        run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_::t --test-threads 1
+        run: cargo nextest run --verbose tests::ipa_prove_and_verify_::t --test-threads 1
      - name: IPA prove and verify tests (ipa outputs)
-        run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_ipa_output
+        run: cargo nextest run --verbose tests::ipa_prove_and_verify_ipa_output
      - name: KZG prove and verify tests single inner col
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_single_col
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_single_col
      - name: KZG prove and verify tests triple inner col
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_triple_col
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_triple_col
      - name: KZG prove and verify tests quadruple inner col
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_quadruple_col
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_quadruple_col
      - name: KZG prove and verify tests octuple inner col
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_octuple_col --test-threads 8
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_octuple_col --test-threads 8
      - name: KZG prove and verify tests (kzg outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_kzg_output
      - name: KZG prove and verify tests (public outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_::t
      - name: KZG prove and verify tests (public inputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_public_input
      - name: KZG prove and verify tests (fixed params)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_fixed_params
      - name: KZG prove and verify tests (hashed outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed
+        run: cargo nextest run --verbose tests::kzg_prove_and_verify_hashed

  # prove-and-verify-tests-gpu:
  #   runs-on: GPU
@@ -541,21 +545,21 @@ jobs:
  #         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
+  #       run: cargo nextest run --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
+  #       run: cargo nextest run --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
+  #       run: cargo nextest run --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
+  #       run: cargo nextest run --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
+  #       run: cargo nextest run --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
+  #       run: cargo nextest run --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
+  #       run: cargo nextest run --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
+  #       run: cargo nextest run --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1

  prove-and-verify-mock-aggr-tests:
    permissions:
@@ -576,7 +580,7 @@ jobs:
          crate: cargo-nextest
          locked: true
      - name: Mock aggr tests (KZG)
-        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_mock_prove_and_verify_  --test-threads 8
+        run: cargo nextest run --verbose tests_aggr::kzg_aggr_mock_prove_and_verify_  --test-threads 8

  # prove-and-verify-aggr-tests-gpu:
  #   runs-on: GPU
@@ -617,7 +621,7 @@ jobs:
          crate: cargo-nextest
          locked: true
      - name: KZG tests
-        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 4 -- --include-ignored
+        run: cargo nextest run --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 4 -- --include-ignored

  prove-and-verify-aggr-evm-tests:
    permissions:
@@ -642,7 +646,7 @@ jobs:
      - name: Install Anvil
        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
+        run: cargo nextest run  --verbose tests_evm::kzg_evm_aggr_prove_and_verify_::t --test-threads 4 -- --include-ignored

  examples:
    permissions:
@@ -691,7 +695,7 @@ jobs:
      - name: Install Anvil
        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
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --profile=test-runs
      - name: Run pytest
        run: source .env/bin/activate; pip install pytest-asyncio; pytest -vv

@@ -719,15 +723,15 @@ jobs:
      - name: Setup Virtual Env and Install python dependencies
        run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt;
      - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --profile=test-runs
      - name: Public inputs
-        run: source .env/bin/activate; cargo nextest run --release --verbose tests::accuracy_measurement_public_inputs_
+        run: source .env/bin/activate; cargo nextest run --verbose tests::accuracy_measurement_public_inputs_
      - name: fixed params
-        run: source .env/bin/activate; cargo nextest run --release --verbose tests::accuracy_measurement_fixed_params_
+        run: source .env/bin/activate; cargo nextest run --verbose tests::accuracy_measurement_fixed_params_
      - name: Public outputs
-        run: source .env/bin/activate; cargo nextest run --release --verbose tests::accuracy_measurement_public_outputs_
+        run: source .env/bin/activate; cargo nextest run --verbose tests::accuracy_measurement_public_outputs_
      - name: Public outputs + resources
-        run: source .env/bin/activate; cargo nextest run --release --verbose tests::resources_accuracy_measurement_public_outputs_
+        run: source .env/bin/activate; cargo nextest run --verbose tests::resources_accuracy_measurement_public_outputs_

  python-integration-tests:
    permissions:
@@ -776,7 +780,9 @@ jobs:
      - name: Setup Virtual Env and Install python dependencies
        run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt; python -m ensurepip --upgrade
      - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --profile=test-runs
+      - name: All notebooks
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::run_notebook_ --test-threads 1
      - name: Voice tutorial
        run: source .env/bin/activate; cargo nextest run py_tests::tests::voice_
      - name: Neural bow
@@ -796,8 +802,6 @@ jobs:
      #     # now dump the contents of the file into a file called kaggle.json
      #     echo $KAGGLE_API_KEY > /home/ubuntu/.kaggle/kaggle.json
      #     chmod 600 /home/ubuntu/.kaggle/kaggle.json
-      - name: All notebooks
-        run: source .env/bin/activate; cargo nextest run py_tests::tests::run_notebook_ --test-threads 1
      - name: NBEATS tutorial
        run: source .env/bin/activate; cargo nextest run py_tests::tests::nbeats_
      # - name: Reusable verifier tutorial
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -288,9 +288,13 @@ uniffi_testing = { git = "https://github.com/ElusAegis/uniffi-rs", branch = "fea
 rustflags = ["-C", "relocation-model=pic"]
 lto = "fat"
 codegen-units = 1
-# panic = "abort"
+#panic = "abort"


+[profile.test-runs]
+inherits = "dev"
+opt-level = 3
+
 [package.metadata.wasm-pack.profile.release]
 wasm-opt = [
    "-O4",
--- a/examples/notebooks/generalized_inverse.ipynb
+++ b/examples/notebooks/generalized_inverse.ipynb
@@ -77,6 +77,7 @@
      "outputs": [],
      "source": [
        "gip_run_args = ezkl.PyRunArgs()\n",
+        "gip_run_args.ignore_range_check_inputs_outputs = True\n",
        "gip_run_args.input_visibility = \"polycommit\"  # matrix and generalized inverse commitments\n",
        "gip_run_args.output_visibility = \"fixed\"   # no parameters used\n",
        "gip_run_args.param_visibility = \"fixed\" # should be Tensor(True)"
@@ -335,9 +336,9 @@
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
-      "version": "3.9.15"
+      "version": "3.9.13"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/mean_postgres.ipynb
+++ b/examples/notebooks/mean_postgres.ipynb
@@ -308,8 +308,11 @@
    "compiled_filename = os.path.join('lol.compiled')\n",
    "settings_filename = os.path.join('settings.json')\n",
    "\n",
+    "run_args = ezkl.PyRunArgs()\n",
+    "run_args.decomp_legs = 4\n",
+    "\n",
    "# Generate settings using ezkl\n",
-    "res = ezkl.gen_settings(onnx_filename, settings_filename)\n",
+    "res = ezkl.gen_settings(onnx_filename, settings_filename, py_run_args=run_args)\n",
    "\n",
    "assert res == True\n",
    "\n",
--- a/examples/notebooks/set_membership.ipynb
+++ b/examples/notebooks/set_membership.ipynb
@@ -167,6 +167,8 @@
        "run_args = ezkl.PyRunArgs()\n",
        "# \"hashed/private\" means that the output of the hashing is not visible to the verifier and is instead fed into the computational graph\n",
        "run_args.input_visibility = \"hashed/private/0\"\n",
+        "# as the inputs are felts we turn off input range checks\n",
+        "run_args.ignore_range_check_inputs_outputs = True\n",
        "# we set it to fix the set we want to check membership for\n",
        "run_args.param_visibility = \"fixed\"\n",
        "# the output is public -- set membership fails if it is not = 0\n",
@@ -519,4 +521,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/solvency.ipynb
+++ b/examples/notebooks/solvency.ipynb
@@ -204,6 +204,7 @@
        "run_args = ezkl.PyRunArgs()\n",
        "# \"polycommit\" means that the output of the hashing is not visible to the verifier and is instead fed into the computational graph\n",
        "run_args.input_visibility = \"polycommit\"\n",
+        "run_args.ignore_range_check_inputs_outputs = True\n",
        "# the parameters are public\n",
        "run_args.param_visibility = \"fixed\"\n",
        "# the output is public (this is the inequality test)\n",
@@ -514,4 +515,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/univ3-da.ipynb
+++ b/examples/notebooks/univ3-da.ipynb
@@ -20,7 +20,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": 2,
+            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -60,7 +60,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": 3,
+            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -94,7 +94,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": 4,
+            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -134,7 +134,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": 44,
+            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -183,7 +183,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": 6,
+            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -201,6 +201,7 @@
                "run_args.input_visibility = \"public\"\n",
                "run_args.param_visibility = \"private\"\n",
                "run_args.output_visibility = \"public\"\n",
+                "run_args.decomp_legs=6\n",
                "run_args.num_inner_cols = 1\n",
                "run_args.variables = [(\"batch_size\", 1)]"
            ]
--- a/src/bindings/python.rs
+++ b/src/bindings/python.rs
@@ -207,6 +207,9 @@ struct PyRunArgs {
    /// bool: Should the circuit use unbounded lookups for log
    #[pyo3(get, set)]
    pub bounded_log_lookup: bool,
+    /// bool: Should the circuit use range checks for inputs and outputs (set to false if the input is a felt)
+    #[pyo3(get, set)]
+    pub ignore_range_check_inputs_outputs: bool,
 }

 /// default instantiation of PyRunArgs
@@ -239,6 +242,7 @@ impl From<PyRunArgs> for RunArgs {
            commitment: Some(py_run_args.commitment.into()),
            decomp_base: py_run_args.decomp_base,
            decomp_legs: py_run_args.decomp_legs,
+            ignore_range_check_inputs_outputs: py_run_args.ignore_range_check_inputs_outputs,
        }
    }
 }
@@ -263,6 +267,7 @@ impl Into<PyRunArgs> for RunArgs {
            commitment: self.commitment.into(),
            decomp_base: self.decomp_base,
            decomp_legs: self.decomp_legs,
+            ignore_range_check_inputs_outputs: self.ignore_range_check_inputs_outputs,
        }
    }
 }
--- a/src/circuit/ops/base.rs
+++ b/src/circuit/ops/base.rs
@@ -17,7 +17,6 @@ pub enum BaseOp {
    Sub,
    SumInit,
    Sum,
-    IsBoolean,
 }

 /// Matches a [BaseOp] to an operation over inputs
@@ -34,7 +33,6 @@ impl BaseOp {
            BaseOp::Add => a + b,
            BaseOp::Sub => a - b,
            BaseOp::Mult => a * b,
-            BaseOp::IsBoolean => b,
            _ => panic!("nonaccum_f called on accumulating operation"),
        }
    }
@@ -74,7 +72,6 @@ impl BaseOp {
            BaseOp::Mult => "MULT",
            BaseOp::Sum => "SUM",
            BaseOp::SumInit => "SUMINIT",
-            BaseOp::IsBoolean => "ISBOOLEAN",
        }
    }

@@ -90,7 +87,6 @@ impl BaseOp {
            BaseOp::Mult => (0, 1),
            BaseOp::Sum => (-1, 2),
            BaseOp::SumInit => (0, 1),
-            BaseOp::IsBoolean => (0, 1),
        }
    }

@@ -106,7 +102,6 @@ impl BaseOp {
            BaseOp::Mult => 2,
            BaseOp::Sum => 1,
            BaseOp::SumInit => 1,
-            BaseOp::IsBoolean => 0,
        }
    }

@@ -122,7 +117,6 @@ impl BaseOp {
            BaseOp::SumInit => 0,
            BaseOp::CumProd => 1,
            BaseOp::CumProdInit => 0,
-            BaseOp::IsBoolean => 0,
        }
    }
 }
--- a/src/circuit/ops/chip.rs
+++ b/src/circuit/ops/chip.rs
@@ -394,7 +394,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
                nonaccum_selectors.insert((BaseOp::Add, i, j), meta.selector());
                nonaccum_selectors.insert((BaseOp::Sub, i, j), meta.selector());
                nonaccum_selectors.insert((BaseOp::Mult, i, j), meta.selector());
-                nonaccum_selectors.insert((BaseOp::IsBoolean, i, j), meta.selector());
            }
        }

@@ -428,24 +427,13 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
                // Get output expressions for each input channel
                let (rotation_offset, rng) = base_op.query_offset_rng();

-                let constraints = match base_op {
-                    BaseOp::IsBoolean => {
-                        let expected_output: Tensor<Expression<F>> = output
-                            .query_rng(meta, *block_idx, *inner_col_idx, 0, 1)
-                            .expect("non accum: output query failed");
+                let constraints = {
+                    let expected_output: Tensor<Expression<F>> = output
+                        .query_rng(meta, *block_idx, *inner_col_idx, rotation_offset, rng)
+                        .expect("non accum: output query failed");

-                        let output = expected_output[base_op.constraint_idx()].clone();
-
-                        vec![(output.clone()) * (output.clone() - Expression::Constant(F::from(1)))]
-                    }
-                    _ => {
-                        let expected_output: Tensor<Expression<F>> = output
-                            .query_rng(meta, *block_idx, *inner_col_idx, rotation_offset, rng)
-                            .expect("non accum: output query failed");
-
-                        let res = base_op.nonaccum_f((qis[0].clone(), qis[1].clone()));
-                        vec![expected_output[base_op.constraint_idx()].clone() - res]
-                    }
+                    let res = base_op.nonaccum_f((qis[0].clone(), qis[1].clone()));
+                    vec![expected_output[base_op.constraint_idx()].clone() - res]
                };

                Constraints::with_selector(selector, constraints)
--- a/src/circuit/ops/errors.rs
+++ b/src/circuit/ops/errors.rs
@@ -106,4 +106,7 @@ pub enum CircuitError {
    /// Visibility has not been set
    #[error("visibility has not been set")]
    UnsetVisibility,
+    /// A decomposition base overflowed
+    #[error("decomposition base overflowed")]
+    DecompositionBaseOverflow,
 }
--- a/src/circuit/ops/hybrid.rs
+++ b/src/circuit/ops/hybrid.rs
@@ -76,7 +76,10 @@ pub enum HybridOp {
        output_scale: utils::F32,
        axes: Vec<usize>,
    },
-    RangeCheck(Tolerance),
+    Output {
+        tol: Tolerance,
+        decomp: bool,
+    },
    Greater,
    GreaterEqual,
    Less,
@@ -178,7 +181,9 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                    input_scale, output_scale, axes
                )
            }
-            HybridOp::RangeCheck(p) => format!("RANGECHECK (tol={:?})", p),
+            HybridOp::Output { tol, decomp } => {
+                format!("OUTPUT (tol={:?}, decomp={})", tol, decomp)
+            }
            HybridOp::Greater => "GREATER".to_string(),
            HybridOp::GreaterEqual => "GREATEREQUAL".to_string(),
            HybridOp::Less => "LESS".to_string(),
@@ -314,12 +319,13 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                *output_scale,
                axes,
            )?,
-            HybridOp::RangeCheck(tol) => layouts::range_check_percent(
+            HybridOp::Output { tol, decomp } => layouts::output(
                config,
                region,
                values[..].try_into()?,
                tol.scale,
                tol.val,
+                *decomp,
            )?,
            HybridOp::Greater => layouts::greater(config, region, values[..].try_into()?)?,
            HybridOp::GreaterEqual => {
--- a/src/circuit/ops/layouts.rs
+++ b/src/circuit/ops/layouts.rs
@@ -155,13 +155,13 @@ pub(crate) fn div<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
        .into()
    };
    claimed_output.reshape(input_dims)?;
-    let claimed_output = region.assign(&config.custom_gates.output, &claimed_output)?;
-    region.increment(claimed_output.len());
-
-    // here we decompose and extract the sign of the input
-    let sign = sign(config, region, &[claimed_output.clone()])?;
+    // implicitly check if the prover provided output is within range
+    let claimed_output = identity(config, region, &[claimed_output], true)?;
    // check if x is too large only if the decomp would support overflow in the previous op
    if (IntegerRep::MAX).abs() < ((region.base() as i128).pow(region.legs() as u32)) - 1 {
+        // here we decompose and extract the sign of the input
+        let sign = sign(config, region, &[claimed_output.clone()])?;
+
        let abs_value = pairwise(
            config,
            region,
@@ -221,9 +221,9 @@ pub(crate) fn recip<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
        .into()
    };
    claimed_output.reshape(input_dims)?;
-    let claimed_output = region.assign(&config.custom_gates.output, &claimed_output)?;
-    region.increment(claimed_output.len());

+    // implicitly check if the prover provided output is within range
+    let claimed_output = identity(config, region, &[claimed_output], true)?;
    // divide by input_scale
    let zero_inverse_val =
        tensor::ops::nonlinearities::zero_recip(felt_to_integer_rep(output_scale) as f64)[0];
@@ -254,10 +254,10 @@ pub(crate) fn recip<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
        BaseOp::Mult,
    )?;

-    // here we decompose and extract the sign of the input
-    let sign = sign(config, region, &[masked_output.clone()])?;
    // check if x is too large only if the decomp would support overflow in the previous op
    if (IntegerRep::MAX).abs() < ((region.base() as i128).pow(region.legs() as u32)) - 1 {
+        // here we decompose and extract the sign of the input
+        let sign = sign(config, region, &[masked_output.clone()])?;
        let abs_value = pairwise(
            config,
            region,
@@ -346,12 +346,8 @@ pub fn sqrt<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
        .into()
    };
    claimed_output.reshape(input_dims)?;
-    let claimed_output = region.assign(&config.custom_gates.output, &claimed_output)?;
-    region.increment(claimed_output.len());
-
-    // force the output to be positive or zero
+    // force the output to be positive or zero, also implicitly checks that the ouput is in range
    let claimed_output = abs(config, region, &[claimed_output.clone()])?;
-
    // rescaled input
    let rescaled_input = pairwise(config, region, &[input.clone(), unit_scale], BaseOp::Mult)?;

@@ -3923,11 +3919,24 @@ pub(crate) fn identity<F: PrimeField + TensorType + PartialOrd + std::hash::Hash
    config: &BaseConfig<F>,
    region: &mut RegionCtx<F>,
    values: &[ValTensor<F>; 1],
+    decomp: bool,
 ) -> Result<ValTensor<F>, CircuitError> {
    let mut output = values[0].clone();
    if !output.all_prev_assigned() {
-        output = region.assign(&config.custom_gates.output, &values[0])?;
-        region.increment(output.len());
+        // checks they are in range
+        if decomp {
+            output = decompose(
+                config,
+                region,
+                &[output.clone()],
+                &region.base(),
+                &region.legs(),
+            )?
+            .1;
+        } else {
+            output = region.assign(&config.custom_gates.output, &values[0])?;
+            region.increment(output.len());
+        }
    }

    Ok(output)
@@ -3948,23 +3957,8 @@ pub(crate) fn boolean_identity<F: PrimeField + TensorType + PartialOrd + std::ha
    } else {
        values[0].clone()
    };
-    // Enable the selectors
-    if !region.is_dummy() {
-        (0..output.len())
-            .map(|j| {
-                let index = region.linear_coord() - j - 1;

-                let (x, y, z) = config.custom_gates.output.cartesian_coord(index);
-                let selector = config
-                    .custom_gates
-                    .selectors
-                    .get(&(BaseOp::IsBoolean, x, y));
-
-                region.enable(selector, z)?;
-                Ok(())
-            })
-            .collect::<Result<Vec<_>, CircuitError>>()?;
-    }
+    range_check(config, region, values, &(0, 1))?;

    Ok(output)
 }
@@ -4417,7 +4411,7 @@ pub fn floor<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
    legs: usize,
 ) -> Result<ValTensor<F>, CircuitError> {
    // decompose with base scale and then set the last element to zero
-    let decomposition = decompose(config, region, values, &(scale.0 as usize), &legs)?;
+    let decomposition = decompose(config, region, values, &(scale.0 as usize), &legs)?.0;
    // set the last element to zero and then recompose, we don't actually need to assign here
    // as this will automatically be assigned in the recompose function and uses the constant caching of RegionCtx
    let zero = ValType::Constant(F::ZERO);
@@ -4530,7 +4524,7 @@ pub fn ceil<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
    legs: usize,
 ) -> Result<ValTensor<F>, CircuitError> {
    // decompose with base scale and then set the last element to zero
-    let decomposition = decompose(config, region, values, &(scale.0 as usize), &legs)?;
+    let decomposition = decompose(config, region, values, &(scale.0 as usize), &legs)?.0;
    // set the last element to zero and then recompose, we don't actually need to assign here
    // as this will automatically be assigned in the recompose function and uses the constant caching of RegionCtx
    let zero = ValType::Constant(F::ZERO);
@@ -4684,7 +4678,7 @@ pub fn ln<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
        .into()
    };
    claimed_output.reshape(input.dims())?;
-    region.assign(&config.custom_gates.output, &claimed_output)?;
+    let claimed_output = identity(&config, region, &[claimed_output], true)?;
    region.increment(claimed_output.len());

    let pow2_of_claimed_output = nonlinearity(
@@ -4930,7 +4924,7 @@ pub fn round<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
    legs: usize,
 ) -> Result<ValTensor<F>, CircuitError> {
    // decompose with base scale and then set the last element to zero
-    let decomposition = decompose(config, region, values, &(scale.0 as usize), &legs)?;
+    let decomposition = decompose(config, region, values, &(scale.0 as usize), &legs)?.0;
    // set the last element to zero and then recompose, we don't actually need to assign here
    // as this will automatically be assigned in the recompose function and uses the constant caching of RegionCtx
    let zero = ValType::Constant(F::ZERO);
@@ -5074,7 +5068,7 @@ pub fn round_half_to_even<F: PrimeField + TensorType + PartialOrd + std::hash::H
    legs: usize,
 ) -> Result<ValTensor<F>, CircuitError> {
    // decompose with base scale and then set the last element to zero
-    let decomposition = decompose(config, region, values, &(scale.0 as usize), &legs)?;
+    let decomposition = decompose(config, region, values, &(scale.0 as usize), &legs)?.0;
    // set the last element to zero and then recompose, we don't actually need to assign here
    // as this will automatically be assigned in the recompose function and uses the constant caching of RegionCtx
    let zero = ValType::Constant(F::ZERO);
@@ -5182,59 +5176,64 @@ pub(crate) fn recompose<F: PrimeField + TensorType + PartialOrd + std::hash::Has
    values: &[ValTensor<F>; 1],
    base: &usize,
 ) -> Result<ValTensor<F>, CircuitError> {
-    let input = values[0].clone();
+    let mut input = values[0].clone();

    let first_dims = input.dims().to_vec()[..input.dims().len() - 1].to_vec();
+    let num_first_dims = first_dims.iter().product::<usize>();
    let n = input.dims().last().unwrap() - 1;

-    let is_assigned = !input.all_prev_assigned();
+    if !input.all_prev_assigned() {
+        input = region.assign(&config.custom_gates.inputs[0], &input)?;
+        region.increment(input.len());
+    }

-    let bases: ValTensor<F> = Tensor::from(
-        (0..n)
-            .rev()
-            .map(|x| ValType::Constant(integer_rep_to_felt(base.pow(x as u32) as IntegerRep))),
-    )
+    // to force the bases to be assigned
+    if input.is_singleton() {
+        input.reshape(&[1])?;
+    }
+
+    let mut bases: ValTensor<F> = Tensor::from({
+        (0..num_first_dims)
+            .flat_map(|_| {
+                (0..n).rev().map(|x| {
+                    let base = (*base).checked_pow(x as u32);
+                    if let Some(base) = base {
+                        Ok(ValType::Constant(integer_rep_to_felt(base as IntegerRep)))
+                    } else {
+                        Err(CircuitError::DecompositionBaseOverflow)
+                    }
+                })
+            })
+            .collect::<Result<Vec<_>, CircuitError>>()?
+            .into_iter()
+    })
    .into();
+    let mut bases_dims = first_dims.clone();
+    bases_dims.push(n);
+    bases.reshape(&bases_dims)?;

-    // multiply and sum the values
-    let mut output: Tensor<Tensor<ValType<F>>> = Tensor::new(None, &first_dims)?;
+    // equation needs to be constructed as ij,j->i but for arbitrary n dims we need to construct this dynamically
+    // indices should map in order of the alphabet
+    // start with lhs
+    let lhs = ASCII_ALPHABET.chars().take(input.dims().len()).join("");
+    let rhs = ASCII_ALPHABET.chars().take(input.dims().len() - 1).join("");

-    let cartesian_coord = first_dims
-        .iter()
-        .map(|x| 0..*x)
-        .multi_cartesian_product()
-        .collect::<Vec<_>>();
+    let equation = format!("{},{}->{}", lhs, lhs, rhs);

-    let inner_loop_function =
-        |i: usize, region: &mut RegionCtx<F>| -> Result<Tensor<ValType<F>>, CircuitError> {
-            let coord = cartesian_coord[i].clone();
-            let slice = coord.iter().map(|x| *x..*x + 1).collect::<Vec<_>>();
-            let mut sliced_input = input.get_slice(&slice)?;
-            sliced_input.flatten();
+    let mut sign_slice = first_dims.iter().map(|x| 0..*x).collect::<Vec<_>>();
+    sign_slice.push(0..1);
+    let mut rest_slice = first_dims.iter().map(|x| 0..*x).collect::<Vec<_>>();
+    rest_slice.push(1..n + 1);

-            if !is_assigned {
-                sliced_input = region.assign(&config.custom_gates.inputs[0], &sliced_input)?;
-                region.increment(sliced_input.len());
-            }
+    let sign = input.get_slice(&sign_slice)?;
+    let rest = input.get_slice(&rest_slice)?;

-            // get the sign bit and make sure it is valid
-            let sign = sliced_input.first()?;
-            let rest = sliced_input.get_slice(&[1..sliced_input.len()])?;
+    // now add the rhs
+    let prod_recomp = einsum(config, region, &[rest.clone(), bases], &equation)?;
+    let mut signed_recomp = pairwise(config, region, &[prod_recomp, sign], BaseOp::Mult)?;
+    signed_recomp.reshape(&first_dims)?;

-            let prod_decomp = dot(config, region, &[rest, bases.clone()])?;
-
-            let signed_decomp = pairwise(config, region, &[prod_decomp, sign], BaseOp::Mult)?;
-
-            Ok(signed_decomp.get_inner_tensor()?.clone())
-        };
-
-    region.apply_in_loop(&mut output, inner_loop_function)?;
-
-    let mut combined_output = output.combine()?;
-
-    combined_output.reshape(&first_dims)?;
-
-    Ok(combined_output.into())
+    Ok(signed_recomp.into())
 }

 pub(crate) fn decompose<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
@@ -5243,24 +5242,35 @@ pub(crate) fn decompose<F: PrimeField + TensorType + PartialOrd + std::hash::Has
    values: &[ValTensor<F>; 1],
    base: &usize,
    n: &usize,
-) -> Result<ValTensor<F>, CircuitError> {
+) -> Result<(ValTensor<F>, ValTensor<F>), CircuitError> {
    let mut input = values[0].clone();

-    let is_assigned = !input.all_prev_assigned();
-
-    if !is_assigned {
+    if !input.all_prev_assigned() {
        input = region.assign(&config.custom_gates.inputs[0], &input)?;
    }

-    let mut bases: ValTensor<F> = Tensor::from(
-        // repeat it input.len() times
-        (0..input.len()).flat_map(|_| {
-            (0..*n)
-                .rev()
-                .map(|x| ValType::Constant(integer_rep_to_felt(base.pow(x as u32) as IntegerRep)))
-        }),
-    )
+    // to force the bases to be assigned
+    if input.is_singleton() {
+        input.reshape(&[1])?;
+    }
+
+    let mut bases: ValTensor<F> = Tensor::from({
+        (0..input.len())
+            .flat_map(|_| {
+                (0..*n).rev().map(|x| {
+                    let base = (*base).checked_pow(x as u32);
+                    if let Some(base) = base {
+                        Ok(ValType::Constant(integer_rep_to_felt(base as IntegerRep)))
+                    } else {
+                        Err(CircuitError::DecompositionBaseOverflow)
+                    }
+                })
+            })
+            .collect::<Result<Vec<_>, CircuitError>>()?
+            .into_iter()
+    })
    .into();
+
    let mut bases_dims = input.dims().to_vec();
    bases_dims.push(*n);
    bases.reshape(&bases_dims)?;
@@ -5279,7 +5289,7 @@ pub(crate) fn decompose<F: PrimeField + TensorType + PartialOrd + std::hash::Has

        claimed_output.into()
    };
-    region.assign(&config.custom_gates.output, &claimed_output)?;
+    let claimed_output = region.assign(&config.custom_gates.output, &claimed_output)?;
    region.increment(claimed_output.len());

    let input_slice = input.dims().iter().map(|x| 0..*x).collect::<Vec<_>>();
@@ -5324,9 +5334,9 @@ pub(crate) fn decompose<F: PrimeField + TensorType + PartialOrd + std::hash::Has

    let signed_decomp = pairwise(config, region, &[prod_decomp, sign], BaseOp::Mult)?;

-    enforce_equality(config, region, &[input, signed_decomp])?;
+    enforce_equality(config, region, &[input.clone(), signed_decomp])?;

-    Ok(claimed_output)
+    Ok((claimed_output, input))
 }

 pub(crate) fn sign<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
@@ -5334,7 +5344,7 @@ pub(crate) fn sign<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
    region: &mut RegionCtx<F>,
    values: &[ValTensor<F>; 1],
 ) -> Result<ValTensor<F>, CircuitError> {
-    let mut decomp = decompose(config, region, values, &region.base(), &region.legs())?;
+    let mut decomp = decompose(config, region, values, &region.base(), &region.legs())?.0;
    // get every n elements now, which correspond to the sign bit
    decomp.get_every_n(region.legs() + 1)?;
    decomp.reshape(values[0].dims())?;
@@ -5616,7 +5626,7 @@ pub fn softmax<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
 /// ```
 /// use ezkl::tensor::Tensor;
 /// use ezkl::fieldutils::IntegerRep;
-/// use ezkl::circuit::ops::layouts::range_check_percent;
+/// use ezkl::circuit::ops::layouts::output;
 ///  use ezkl::tensor::val::ValTensor;
 /// use halo2curves::bn256::Fr as Fp;
 /// use ezkl::circuit::region::RegionCtx;
@@ -5634,28 +5644,32 @@ pub fn softmax<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
 ///    Some(&[101, 201, 302, 403, 503, 603]),
 ///   &[2, 3],
 /// ).unwrap());
-/// let result = range_check_percent::<Fp>(&dummy_config, &mut dummy_region, &[x, y], 1024.0.into(), 1.0).unwrap();
+/// let result = output::<Fp>(&dummy_config, &mut dummy_region, &[x, y], 1024.0.into(), 1.0, false).unwrap();
 /// ```
-pub fn range_check_percent<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
+pub fn output<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
    config: &BaseConfig<F>,
    region: &mut RegionCtx<F>,
    values: &[ValTensor<F>; 2],
    scale: utils::F32,
    tol: f32,
+    decomp: bool,
 ) -> Result<ValTensor<F>, CircuitError> {
-    if tol == 0.0 {
-        // regular equality constraint
-        return enforce_equality(config, region, values);
-    }
-
    let mut values = [values[0].clone(), values[1].clone()];

-    values[0] = region.assign(&config.custom_gates.inputs[0], &values[0])?;
-    values[1] = region.assign(&config.custom_gates.inputs[1], &values[1])?;
-    let total_assigned_0 = values[0].len();
-    let total_assigned_1 = values[1].len();
-    let total_assigned = std::cmp::max(total_assigned_0, total_assigned_1);
-    region.increment(total_assigned);
+    if !values[0].all_prev_assigned() {
+        // range check the outputs
+        values[0] = layouts::identity(config, region, &[values[0].clone()], decomp)?;
+    }
+
+    if !values[1].all_prev_assigned() {
+        // range check the outputs
+        values[1] = layouts::identity(config, region, &[values[1].clone()], decomp)?;
+    }
+
+    if tol == 0.0 {
+        // regular equality constraint
+        return enforce_equality(config, region, &[values[0].clone(), values[1].clone()]);
+    }

    // Calculate the difference between the expected output and actual output
    let diff = pairwise(config, region, &values, BaseOp::Sub)?;
--- a/src/circuit/ops/mod.rs
+++ b/src/circuit/ops/mod.rs
@@ -159,6 +159,8 @@ pub struct Input {
    pub scale: crate::Scale,
    ///
    pub datum_type: InputType,
+    /// decomp check
+    pub decomp: bool,
 }

 impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input {
@@ -196,6 +198,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input
                    config,
                    region,
                    values[..].try_into()?,
+                    self.decomp,
                )?)),
            }
        } else {
@@ -251,15 +254,18 @@ pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
    ///
    #[serde(skip)]
    pub pre_assigned_val: Option<ValTensor<F>>,
+    ///
+    pub decomp: bool,
 }

 impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Constant<F> {
    ///
-    pub fn new(quantized_values: Tensor<F>, raw_values: Tensor<f32>) -> Self {
+    pub fn new(quantized_values: Tensor<F>, raw_values: Tensor<f32>, decomp: bool) -> Self {
        Self {
            quantized_values,
            raw_values,
            pre_assigned_val: None,
+            decomp,
        }
    }
    /// Rebase the scale of the constant
@@ -311,7 +317,12 @@ impl<
            self.quantized_values.clone().try_into()?
        };
        // we gotta constrain it once if its used multiple times
-        Ok(Some(layouts::identity(config, region, &[value])?))
+        Ok(Some(layouts::identity(
+            config,
+            region,
+            &[value],
+            self.decomp,
+        )?))
    }

    fn clone_dyn(&self) -> Box<dyn Op<F>> {
--- a/src/circuit/ops/poly.rs
+++ b/src/circuit/ops/poly.rs
@@ -323,7 +323,9 @@ impl<
            PolyOp::Mult => {
                layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Mult)?
            }
-            PolyOp::Identity { .. } => layouts::identity(config, region, values[..].try_into()?)?,
+            PolyOp::Identity { .. } => {
+                layouts::identity(config, region, values[..].try_into()?, false)?
+            }
            PolyOp::Reshape(d) | PolyOp::Flatten(d) => layouts::reshape(values[..].try_into()?, d)?,
            PolyOp::Pad(p) => {
                if values.len() != 1 {
--- a/src/graph/model.rs
+++ b/src/graph/model.rs
@@ -908,6 +908,7 @@ impl Model {
                            n.opkind = SupportedOp::Input(Input {
                                scale,
                                datum_type: inp.datum_type,
+                                decomp: !run_args.ignore_range_check_inputs_outputs,
                            });
                            input_idx += 1;
                            n.out_scale = scale;
@@ -1145,8 +1146,8 @@ impl Model {
                        .iter()
                        .enumerate()
                        .map(|(i, output)| {
-                            let mut tolerance = run_args.tolerance;
-                            tolerance.scale = scale_to_multiplier(output_scales[i]).into();
+                            let mut tol: crate::circuit::Tolerance = run_args.tolerance;
+                            tol.scale = scale_to_multiplier(output_scales[i]).into();

                            let comparators = if run_args.output_visibility == Visibility::Public {
                                let res = vars
@@ -1169,7 +1170,10 @@ impl Model {
                                .layout(
                                    &mut thread_safe_region,
                                    &[output.clone(), comparators],
-                                    Box::new(HybridOp::RangeCheck(tolerance)),
+                                    Box::new(HybridOp::Output {
+                                        tol,
+                                        decomp: !run_args.ignore_range_check_inputs_outputs,
+                                    }),
                                )
                                .map_err(|e| e.into())
                        })
@@ -1446,13 +1450,16 @@ impl Model {
                        .into();
                    comparator.reshape(output.dims())?;

-                    let mut tolerance = run_args.tolerance;
-                    tolerance.scale = scale_to_multiplier(output_scales[i]).into();
+                    let mut tol = run_args.tolerance;
+                    tol.scale = scale_to_multiplier(output_scales[i]).into();

                    dummy_config.layout(
                        &mut region,
                        &[output.clone(), comparator],
-                        Box::new(HybridOp::RangeCheck(tolerance)),
+                        Box::new(HybridOp::Output {
+                            tol,
+                            decomp: !run_args.ignore_range_check_inputs_outputs,
+                        }),
                    )
                })
                .collect::<Result<Vec<_>, _>>();
@@ -1544,6 +1551,7 @@ impl Model {
                        let mut op = crate::circuit::Constant::new(
                            c.quantized_values.clone(),
                            c.raw_values.clone(),
+                            c.decomp,
                        );
                        op.pre_assign(consts[const_idx].clone());
                        n.opkind = SupportedOp::Constant(op);
--- a/src/graph/utilities.rs
+++ b/src/graph/utilities.rs
@@ -384,7 +384,11 @@ pub fn new_op_from_onnx(
            // Quantize the raw value (integers)
            let quantized_value = quantize_tensor(raw_value.clone(), 0, &Visibility::Fixed)?;

-            let c = crate::circuit::ops::Constant::new(quantized_value, raw_value);
+            let c = crate::circuit::ops::Constant::new(
+                quantized_value,
+                raw_value,
+                !run_args.ignore_range_check_inputs_outputs,
+            );
            // Create a constant op
            SupportedOp::Constant(c)
        }
@@ -446,6 +450,7 @@ pub fn new_op_from_onnx(
                inputs[1].replace_opkind(SupportedOp::Input(crate::circuit::ops::Input {
                    scale: 0,
                    datum_type: InputType::TDim,
+                    decomp: false,
                }));
                inputs[1].bump_scale(0);
            }
@@ -522,6 +527,7 @@ pub fn new_op_from_onnx(
                inputs[1].replace_opkind(SupportedOp::Input(crate::circuit::ops::Input {
                    scale: 0,
                    datum_type: InputType::TDim,
+                    decomp: !run_args.ignore_range_check_inputs_outputs,
                }));
                inputs[1].bump_scale(0);
            }
@@ -558,6 +564,7 @@ pub fn new_op_from_onnx(
                inputs[1].replace_opkind(SupportedOp::Input(crate::circuit::ops::Input {
                    scale: 0,
                    datum_type: InputType::TDim,
+                    decomp: !run_args.ignore_range_check_inputs_outputs,
                }));
                inputs[1].bump_scale(0);
            }
@@ -595,6 +602,7 @@ pub fn new_op_from_onnx(
                inputs[1].replace_opkind(SupportedOp::Input(crate::circuit::ops::Input {
                    scale: 0,
                    datum_type: InputType::TDim,
+                    decomp: !run_args.ignore_range_check_inputs_outputs,
                }));
                inputs[1].bump_scale(0);
            }
@@ -632,6 +640,7 @@ pub fn new_op_from_onnx(
                inputs[1].replace_opkind(SupportedOp::Input(crate::circuit::ops::Input {
                    scale: 0,
                    datum_type: InputType::TDim,
+                    decomp: !run_args.ignore_range_check_inputs_outputs,
                }));
                inputs[1].bump_scale(0);
            }
@@ -706,7 +715,11 @@ pub fn new_op_from_onnx(
                constant_scale,
                &run_args.param_visibility,
            )?;
-            let c = crate::circuit::ops::Constant::new(quantized_value, raw_value);
+            let c = crate::circuit::ops::Constant::new(
+                quantized_value,
+                raw_value,
+                run_args.ignore_range_check_inputs_outputs,
+            );
            // Create a constant op
            SupportedOp::Constant(c)
        }
@@ -969,7 +982,11 @@ pub fn new_op_from_onnx(
                DatumType::F64 => (scales.input, InputType::F64),
                _ => return Err(GraphError::UnsupportedDataType(idx, format!("{:?}", dt))),
            };
-            SupportedOp::Input(crate::circuit::ops::Input { scale, datum_type })
+            SupportedOp::Input(crate::circuit::ops::Input {
+                scale,
+                datum_type,
+                decomp: !run_args.ignore_range_check_inputs_outputs,
+            })
        }
        "Cast" => {
            let op = load_op::<Cast>(node.op(), idx, node.op().name().to_string())?;
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -349,6 +349,12 @@ pub struct RunArgs {
        arg(long, default_value = "false")
    )]
    pub bounded_log_lookup: bool,
+    /// Range check inputs and outputs (turn off if the inputs are felts)
+    #[cfg_attr(
+        all(feature = "ezkl", not(target_arch = "wasm32")),
+        arg(long, default_value = "false")
+    )]
+    pub ignore_range_check_inputs_outputs: bool,
 }

 impl Default for RunArgs {
@@ -375,6 +381,7 @@ impl Default for RunArgs {
            commitment: None,
            decomp_base: 16384,
            decomp_legs: 2,
+            ignore_range_check_inputs_outputs: false,
        }
    }
 }
--- a/tests/assets/model.compiled
+++ b/tests/assets/model.compiled
--- a/tests/assets/pk.key
+++ b/tests/assets/pk.key
--- a/tests/assets/proof.json
+++ b/tests/assets/proof.json
--- a/tests/assets/settings.json
+++ b/tests/assets/settings.json
@@ -28,11 +28,12 @@
        "commitment": "KZG",
        "decomp_base": 128,
        "decomp_legs": 2,
-        "bounded_log_lookup": false
+        "bounded_log_lookup": false,
+        "ignore_range_check_inputs_outputs": false
    },
-    "num_rows": 46,
-    "total_assignments": 92,
-    "total_const_size": 3,
+    "num_rows": 236,
+    "total_assignments": 472,
+    "total_const_size": 4,
    "total_dynamic_col_size": 0,
    "max_dynamic_input_len": 0,
    "num_dynamic_lookups": 0,
--- a/tests/assets/vk.key
+++ b/tests/assets/vk.key
--- a/tests/integration_tests.rs
+++ b/tests/integration_tests.rs
@@ -1,7 +1,6 @@
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 #[cfg(test)]
 mod native_tests {
-
    use ezkl::circuit::Tolerance;
    use ezkl::fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep};
    // use ezkl::circuit::table::RESERVED_BLINDING_ROWS_PAD;
@@ -23,6 +22,8 @@ mod native_tests {
    static COMPILE_WASM: Once = Once::new();
    static ENV_SETUP: Once = Once::new();

+    const TEST_BINARY: &str = "test-runs/ezkl";
+
    //Sure to run this once
    #[derive(Debug)]
    #[allow(dead_code)]
@@ -103,7 +104,7 @@ mod native_tests {

    fn download_srs(logrows: u32, commitment: Commitments) {
        // if does not exist, download it
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "get-srs",
                "--logrows",
@@ -206,61 +207,61 @@ mod native_tests {
    ];

    const TESTS: [&str; 98] = [
-        "1l_mlp", //0
-        "1l_slice",
-        "1l_concat",
-        "1l_flatten",
+        "1l_mlp",     //0
+        "1l_slice",   //1
+        "1l_concat",  //2
+        "1l_flatten", //3
        // "1l_average",
-        "1l_div",
-        "1l_pad", // 5
-        "1l_reshape",
-        "1l_eltwise_div",
-        "1l_sigmoid",
-        "1l_sqrt",
-        "1l_softmax", //10
+        "1l_div",         //4
+        "1l_pad",         // 5
+        "1l_reshape",     //6
+        "1l_eltwise_div", //7
+        "1l_sigmoid",     //8
+        "1l_sqrt",        //9
+        "1l_softmax",     //10
        // "1l_instance_norm",
-        "1l_batch_norm",
-        "1l_prelu",
-        "1l_leakyrelu",
-        "1l_gelu_noappx",
+        "1l_batch_norm",  //11
+        "1l_prelu",       //12
+        "1l_leakyrelu",   //13
+        "1l_gelu_noappx", //14
        // "1l_gelu_tanh_appx",
-        "1l_relu", //15
-        "1l_downsample",
-        "1l_tanh",
-        "2l_relu_sigmoid_small",
-        "2l_relu_fc",
-        "2l_relu_small", //20
-        "2l_relu_sigmoid",
-        "1l_conv",
-        "2l_sigmoid_small",
-        "2l_relu_sigmoid_conv",
-        "3l_relu_conv_fc", //25
-        "4l_relu_conv_fc",
-        "1l_erf",
-        "1l_var",
-        "1l_elu",
-        "min", //30
-        "max",
-        "1l_max_pool",
-        "1l_conv_transpose",
-        "1l_upsample",
-        "1l_identity", //35
-        "idolmodel",   // too big evm
-        "trig",        // too big evm
-        "prelu_gmm",
-        "lstm",
-        "rnn", //40
-        "quantize_dequantize",
-        "1l_where",
-        "boolean",
-        "boolean_identity",
-        "decision_tree", // 45
-        "random_forest",
-        "gradient_boosted_trees",
-        "1l_topk",
-        "xgboost",
-        "lightgbm", //50
-        "hummingbird_decision_tree",
+        "1l_relu",                   //15
+        "1l_downsample",             //16
+        "1l_tanh",                   //17
+        "2l_relu_sigmoid_small",     //18
+        "2l_relu_fc",                //19
+        "2l_relu_small",             //20
+        "2l_relu_sigmoid",           //21
+        "1l_conv",                   //22
+        "2l_sigmoid_small",          //23
+        "2l_relu_sigmoid_conv",      //24
+        "3l_relu_conv_fc",           //25
+        "4l_relu_conv_fc",           //26
+        "1l_erf",                    //27
+        "1l_var",                    //28
+        "1l_elu",                    //29
+        "min",                       //30
+        "max",                       //31
+        "1l_max_pool",               //32
+        "1l_conv_transpose",         //33
+        "1l_upsample",               //34
+        "1l_identity",               //35
+        "idolmodel",                 // too big evm
+        "trig",                      // too big evm
+        "prelu_gmm",                 //38
+        "lstm",                      //39
+        "rnn",                       //40
+        "quantize_dequantize",       //41
+        "1l_where",                  //42
+        "boolean",                   //43
+        "boolean_identity",          //44
+        "decision_tree",             // 45
+        "random_forest",             //46
+        "gradient_boosted_trees",    //47
+        "1l_topk",                   //48
+        "xgboost",                   //49
+        "lightgbm",                  //50
+        "hummingbird_decision_tree", //51
        "oh_decision_tree",
        "linear_svc",
        "gather_elements",
@@ -627,7 +628,7 @@ mod native_tests {
                let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                // gen random number between 0.0 and 1.0
                let tolerance = rand::thread_rng().gen_range(0.0..1.0) * 100.0;
-                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None, tolerance, false, Some(8194), Some(5));
+                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None, tolerance, false, Some(32776), Some(5));
                test_dir.close().unwrap();
            }

@@ -981,7 +982,7 @@ mod native_tests {
                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(), "private", "fixed", "public", 1, "resources", None, 0.0, false, None, None);
+                mock(path, test.to_string(), "private", "fixed", "public", 1, "resources", None, 0.0, false, None, Some(5));
                test_dir.close().unwrap();
            }
        });
@@ -1555,7 +1556,7 @@ mod native_tests {
                .save(format!("{}/{}/witness_bad.json", test_dir, example_name).into())
                .unwrap();

-            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
                .args([
                    "mock",
                    "-W",
@@ -1567,7 +1568,7 @@ mod native_tests {
                .expect("failed to execute process");
            assert!(status.success());

-            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
                .args([
                    "mock",
                    "-W",
@@ -1579,7 +1580,7 @@ mod native_tests {
                .expect("failed to execute process");
            assert!(status.success());

-            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
                .args([
                    "mock",
                    "-W",
@@ -1591,7 +1592,7 @@ mod native_tests {
                .expect("failed to execute process");
            assert!(!status.success());
        } else {
-            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
                .args([
                    "mock",
                    "-W",
@@ -1640,6 +1641,11 @@ mod native_tests {
            format!("--commitment={}", commitment),
        ];

+        // if output-visibility is fixed set --range-check-inputs-outputs to False
+        if output_visibility == "fixed" {
+            args.push("--ignore-range-check-inputs-outputs".to_string());
+        }
+
        if let Some(decomp_base) = decomp_base {
            args.push(format!("--decomp-base={}", decomp_base));
        }
@@ -1652,7 +1658,7 @@ mod native_tests {
            args.push("--bounded-log-lookup".to_string());
        }

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(args)
            .status()
            .expect("failed to execute process");
@@ -1682,7 +1688,7 @@ mod native_tests {
            calibrate_args.push(scales);
        }

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(calibrate_args)
            .status()
            .expect("failed to execute process");
@@ -1706,7 +1712,7 @@ mod native_tests {
            *tolerance = 0.0;
        }

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "compile-circuit",
                "-M",
@@ -1723,7 +1729,7 @@ mod native_tests {
            .expect("failed to execute process");
        assert!(status.success());

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "gen-witness",
                "-D",
@@ -1791,7 +1797,7 @@ mod native_tests {

    // Mock prove (fast, but does not cover some potential issues)
    fn render_circuit(test_dir: &str, example_name: String) {
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "render-circuit",
                "-M",
@@ -1822,7 +1828,7 @@ mod native_tests {
            Commitments::KZG,
            2,
        );
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "mock-aggregate",
                "--logrows=23",
@@ -1860,7 +1866,7 @@ mod native_tests {

        download_srs(23, commitment);
        // now setup-aggregate
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "setup-aggregate",
                "--sample-snarks",
@@ -1876,7 +1882,7 @@ mod native_tests {
            .expect("failed to execute process");
        assert!(status.success());

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "aggregate",
                "--logrows=23",
@@ -1891,7 +1897,7 @@ mod native_tests {
            .status()
            .expect("failed to execute process");
        assert!(status.success());
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "verify-aggr",
                "--logrows=23",
@@ -1941,7 +1947,7 @@ mod native_tests {
        let private_key = format!("--private-key={}", *ANVIL_DEFAULT_PRIVATE_KEY);

        // create encoded calldata
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "encode-evm-calldata",
                "--proof-path",
@@ -1963,7 +1969,7 @@ mod native_tests {

        let args = build_args(base_args, &sol_arg);

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(args)
            .status()
            .expect("failed to execute process");
@@ -1979,7 +1985,7 @@ mod native_tests {
            private_key.as_str(),
        ];

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(&args)
            .status()
            .expect("failed to execute process");
@@ -2001,14 +2007,14 @@ mod native_tests {
            rpc_arg.as_str(),
        ];

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(&base_args)
            .status()
            .expect("failed to execute process");
        assert!(status.success());
        // As sanity check, add example that should fail.
        base_args[2] = PF_FAILURE_AGGR;
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(base_args)
            .status()
            .expect("failed to execute process");
@@ -2059,7 +2065,7 @@ mod native_tests {

        init_params(settings_path.clone().into());

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "setup",
                "-M",
@@ -2074,7 +2080,7 @@ mod native_tests {
            .expect("failed to execute process");
        assert!(status.success());

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "prove",
                "-W",
@@ -2092,7 +2098,7 @@ mod native_tests {
            .expect("failed to execute process");
        assert!(status.success());

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "swap-proof-commitments",
                "--proof-path",
@@ -2104,7 +2110,7 @@ mod native_tests {
            .expect("failed to execute process");
        assert!(status.success());

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "verify",
                format!("--settings-path={}", settings_path).as_str(),
@@ -2127,7 +2133,7 @@ mod native_tests {
        // get_srs for the graph_settings_num_instances
        download_srs(1, graph_settings.run_args.commitment.into());

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "verify",
                format!("--settings-path={}", settings_path).as_str(),
@@ -2177,7 +2183,7 @@ mod native_tests {
        let settings_arg = format!("--settings-path={}", settings_path);

        // create encoded calldata
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "encode-evm-calldata",
                "--proof-path",
@@ -2197,7 +2203,7 @@ mod native_tests {
        args.push("--sol-code-path");
        args.push(sol_arg.as_str());

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(&args)
            .status()
            .expect("failed to execute process");
@@ -2209,7 +2215,7 @@ mod native_tests {
        args.push("--sol-code-path");
        args.push(sol_arg.as_str());

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(&args)
            .status()
            .expect("failed to execute process");
@@ -2231,14 +2237,14 @@ mod native_tests {
            deployed_addr_arg.as_str(),
        ];

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(&args)
            .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))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(args)
            .status()
            .expect("failed to execute process");
@@ -2297,7 +2303,7 @@ mod native_tests {
                    "--reusable",
                ];

-                let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
                    .args(&args)
                    .status()
                    .expect("failed to execute process");
@@ -2312,7 +2318,7 @@ mod native_tests {
                    "-C=verifier/reusable",
                ];

-                let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
                    .args(&args)
                    .status()
                    .expect("failed to execute process");
@@ -2341,7 +2347,7 @@ mod native_tests {
            &sol_arg_vk,
        ];

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(&args)
            .status()
            .expect("failed to execute process");
@@ -2356,7 +2362,7 @@ mod native_tests {
            "-C=vka",
        ];

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(&args)
            .status()
            .expect("failed to execute process");
@@ -2369,7 +2375,7 @@ mod native_tests {
        let deployed_addr_arg_vk = format!("--addr-vk={}", addr_vk);

        // create encoded calldata
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "encode-evm-calldata",
                "--proof-path",
@@ -2392,7 +2398,7 @@ mod native_tests {
            deployed_addr_arg_vk.as_str(),
        ];

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(&args)
            .status()
            .expect("failed to execute process");
@@ -2425,7 +2431,7 @@ mod native_tests {
            // 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))
+            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
                .args(&args_mod)
                .status()
                .expect("failed to execute process");
@@ -2503,7 +2509,7 @@ mod native_tests {
        let test_input_source = format!("--input-source={}", input_source);
        let test_output_source = format!("--output-source={}", output_source);

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "setup",
                "-M",
@@ -2518,7 +2524,7 @@ mod native_tests {
        assert!(status.success());

        // generate the witness, passing the vk path to generate the necessary kzg commits
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "gen-witness",
                "-D",
@@ -2575,7 +2581,7 @@ mod native_tests {
            }
            input.save(data_path.clone().into()).unwrap();

-            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
                .args([
                    "setup-test-evm-data",
                    "-D",
@@ -2593,7 +2599,7 @@ mod native_tests {
            assert!(status.success());
        }

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "prove",
                "-W",
@@ -2614,7 +2620,7 @@ mod native_tests {
        let settings_arg = format!("--settings-path={}", settings_path);

        // create encoded calldata
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "encode-evm-calldata",
                "--proof-path",
@@ -2633,7 +2639,7 @@ mod native_tests {
        args.push("--sol-code-path");
        args.push(sol_arg.as_str());

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(&args)
            .status()
            .expect("failed to execute process");
@@ -2654,7 +2660,7 @@ mod native_tests {
        args.push("--sol-code-path");
        args.push(sol_arg.as_str());

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(&args)
            .status()
            .expect("failed to execute process");
@@ -2677,7 +2683,7 @@ mod native_tests {
            create_da_args.push(test_on_chain_data_path.as_str());
        }

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(&create_da_args)
            .status()
            .expect("failed to execute process");
@@ -2690,7 +2696,7 @@ mod native_tests {
        };

        let addr_path_da_arg = format!("--addr-path={}/{}/addr_da.txt", test_dir, example_name);
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args([
                "deploy-evm-da",
                format!("--settings-path={}", settings_path).as_str(),
@@ -2728,14 +2734,14 @@ mod native_tests {
            deployed_addr_da_arg.as_str(),
            rpc_arg.as_str(),
        ];
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(&args)
            .status()
            .expect("failed to execute process");
        assert!(status.success());
        // Create a new set of test on chain data only for the on-chain input source
        if input_source != "file" || output_source != "file" {
-            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
                .args([
                    "setup-test-evm-data",
                    "-D",
@@ -2762,7 +2768,7 @@ mod native_tests {
                test_on_chain_data_path.as_str(),
                rpc_arg.as_str(),
            ];
-            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
                .args(&args)
                .status()
                .expect("failed to execute process");
@@ -2778,7 +2784,7 @@ mod native_tests {
            deployed_addr_da_arg.as_str(),
            rpc_arg.as_str(),
        ];
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
            .args(args)
            .status()
            .expect("failed to execute process");
@@ -2789,7 +2795,7 @@ mod native_tests {
        #[cfg(feature = "icicle")]
        let args = [
            "build",
-            "--release",
+            "--profile=test-runs",
            "--bin",
            "ezkl",
            "--features",
@@ -2798,7 +2804,7 @@ mod native_tests {
        #[cfg(feature = "macos-metal")]
        let args = [
            "build",
-            "--release",
+            "--profile=test-runs",
            "--bin",
            "ezkl",
            "--features",
@@ -2806,11 +2812,11 @@ mod native_tests {
        ];
        // not macos-metal and not icicle
        #[cfg(all(not(feature = "icicle"), not(feature = "macos-metal")))]
-        let args = ["build", "--release", "--bin", "ezkl"];
+        let args = ["build", "--profile=test-runs", "--bin", "ezkl"];
        #[cfg(not(feature = "mv-lookup"))]
        let args = [
            "build",
-            "--release",
+            "--profile=test-runs",
            "--bin",
            "ezkl",
            "--no-default-features",
@@ -2831,7 +2837,7 @@ mod native_tests {
        let status = Command::new("wasm-pack")
            .args([
                "build",
-                "--release",
+                "--profile=test-runs",
                "--target",
                "nodejs",
                "--out-dir",
--- a/tests/py_integration_tests.rs
+++ b/tests/py_integration_tests.rs
@@ -126,10 +126,10 @@ mod py_tests {
    }

    const TESTS: [&str; 35] = [
-        "ezkl_demo_batch.ipynb",                   // 0
-        "proof_splitting.ipynb",                   // 1
-        "variance.ipynb",                          // 2
-        "mnist_gan.ipynb",                         // 3
+        "mnist_gan.ipynb",                         // 0
+        "ezkl_demo_batch.ipynb",                   // 1
+        "proof_splitting.ipynb",                   // 2
+        "variance.ipynb",                          // 3
        "keras_simple_demo.ipynb",                 // 4
        "mnist_gan_proof_splitting.ipynb",         // 5
        "hashed_vis.ipynb",                        // 6
Author	SHA1	Message	Date
Alexander Camuto	6f103d2f45	patch large mock	2025-02-03 16:08:24 +00:00
Alexander Camuto	e56f5da273	Update integration_tests.rs	2025-02-03 12:31:14 +00:00
Alexander Camuto	a1ae5114dd	Update layouts.rs	2025-02-03 09:03:46 +00:00
Alexander Camuto	6aba1f5c7b	bump	2025-02-03 09:00:57 +00:00
Alexander Camuto	252ec5453d	patch	2025-02-02 21:26:57 +00:00
Alexander Camuto	d91cf14e56	Update errors.rs	2025-02-02 21:25:57 +00:00
Alexander Camuto	99df087a43	change flag for neg default	2025-02-02 21:25:41 +00:00
Alexander Camuto	49c63586a0	Update layouts.rs	2025-02-02 20:47:57 +00:00
Alexander Camuto	6a84e58920	patch	2025-02-02 14:42:16 +00:00
Alexander Camuto	ccb8310224	Update py_integration_tests.rs	2025-02-02 13:46:21 +00:00
Alexander Camuto	96a5fba806	Update rust.yml	2025-02-02 13:30:24 +00:00
Alexander Camuto	86fc2cf53f	Update mnist_gan_proof_splitting.ipynb	2025-02-02 13:18:29 +00:00
Alexander Camuto	6edcb4fb1d	Update mnist_gan.ipynb	2025-02-02 13:17:25 +00:00
Alexander Camuto	e0b6499ba2	Update integration_tests.rs	2025-02-02 13:02:17 +00:00
Alexander Camuto	ddfe433809	patch	2025-02-02 12:56:05 +00:00
Alexander Camuto	a28916e217	Update integration_tests.rs	2025-02-02 11:09:09 +00:00
Alexander Camuto	ba90aeb5ca	Update rust.yml	2025-02-02 11:07:05 +00:00
Alexander Camuto	fc3f5dc817	patchola	2025-02-02 11:01:56 +00:00
Alexander Camuto	ed76dce4c1	Update rust.yml	2025-02-02 10:48:42 +00:00
Alexander Camuto	43295d95ca	patch nb	2025-02-01 22:07:30 +00:00
Alexander Camuto	a53f7513ba	Merge branch 'ac/range-check-inputs-outputs' of https://github.com/zkonduit/ezkl into ac/range-check-inputs-outputs	2025-02-01 11:21:17 +00:00
Alexander Camuto	6e858b8361	Update solvency.ipynb	2025-02-01 11:21:14 +00:00
dante	28351839b6	Update mean_postgres.ipynb	2025-02-01 01:10:58 +00:00
Alexander Camuto	f5db46f4dd	Update rust.yml	2025-01-31 23:33:11 +00:00
Alexander Camuto	e8f13cefe8	Update layouts.rs	2025-01-31 23:17:32 +00:00
Alexander Camuto	cc29b9600e	toggle for input/output range check	2025-01-31 23:13:19 +00:00
Alexander Camuto	6b02468f0d	Update mean_postgres.ipynb	2025-01-31 16:44:02 +00:00
Alexander Camuto	4c512a59fe	clean up	2025-01-31 13:39:20 +00:00
Alexander Camuto	e7b810f308	Update integration_tests.rs	2025-01-31 12:25:20 +00:00
Alexander Camuto	f6dc2aca3c	Update integration_tests.rs	2025-01-31 12:23:59 +00:00
dante	158971be33	Merge branch 'main' into ac/range-check-inputs-outputs	2025-01-31 10:48:58 +00:00
Alexander Camuto	9a1b1de124	clear cache	2025-01-31 00:38:34 +00:00
Alexander Camuto	87957fe2f6	fix: range-check graph input and outputs	2025-01-30 18:46:17 +00:00