fix: publishing path

This reverts commit 20ac99fdbf.

.github/workflows/engine.yml

@@ -47,6 +47,10 @@ jobs:
           curl -L https://github.com/WebAssembly/binaryen/releases/download/version_116/binaryen-version_116-x86_64-linux.tar.gz | tar xzf -
           export PATH=$PATH:$PWD/binaryen-version_116/bin
           wasm-opt --version
+      - name: Build wasm files for both web and nodejs compilation targets
+        run: |
+            wasm-pack build --release --target nodejs --out-dir ./pkg/nodejs . -- -Z build-std="panic_abort,std"
+            wasm-pack build --release --target web --out-dir ./pkg/web . -- -Z build-std="panic_abort,std" --features web
       - name: Create package.json in pkg folder
         shell: bash
         run: |

.github/workflows/pypi-gpu.yml

@@ -43,6 +43,9 @@ jobs:
             sed "s/ezkl/ezkl-gpu/" pyproject.toml.orig >pyproject.toml
             sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" pyproject.toml.orig >pyproject.toml
 
+      - name: rename ezkl.pyi to ezkl-gpu.pyi
+        run: mv ezkl.pyi ezkl-gpu.pyi
+
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
@@ -76,7 +79,7 @@ jobs:
           pip install ezkl-gpu --no-index --find-links dist --force-reinstall
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: wheels
           path: dist
@@ -92,7 +95,7 @@ jobs:
     # needs: [ macos, windows, linux, linux-cross, musllinux, musllinux-cross ]
     needs: [linux]
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: wheels
       - name: List Files

.github/workflows/pypi.yml

@@ -73,9 +73,9 @@ jobs:
           python -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: dist-macos-${{ matrix.target }}
           path: dist
 
   windows:
@@ -130,9 +130,9 @@ jobs:
           python -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: dist-windows-${{ matrix.target }}
           path: dist
 
   linux:
@@ -203,9 +203,9 @@ jobs:
           python -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: dist-linux-${{ matrix.target }}
           path: dist
 
   musllinux:
@@ -271,9 +271,9 @@ jobs:
             python3 -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: dist-musllinux-${{ matrix.target }}
           path: dist
 
   musllinux-cross:
@@ -334,9 +334,9 @@ jobs:
             python3 -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: dist-musllinux-${{ matrix.platform.target }}
           path: dist
 
   pypi-publish:
@@ -347,9 +347,11 @@ jobs:
     if: "startsWith(github.ref, 'refs/tags/')"
     needs: [macos, windows, linux, musllinux, musllinux-cross]
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: wheels
+          pattern: dist-*
+          merge-multiple: true
+          path: wheels
       - name: List Files
         run: ls -R
       
@@ -375,7 +377,7 @@ jobs:
     needs: pypi-publish
     steps:
       - uses: actions/checkout@v4
-        with: 
+        with:
           persist-credentials: false
       - name: Trigger RTDs build
         uses: dfm/rtds-action@v1

Cargo.lock

@@ -944,7 +944,7 @@ dependencies = [
  "bitflags 2.5.0",
  "cexpr",
  "clang-sys",
- "itertools 0.12.1",
+ "itertools 0.11.0",
  "lazy_static",
  "lazycell",
  "log",
@@ -2397,7 +2397,7 @@ dependencies = [
 [[package]]
 name = "halo2_gadgets"
 version = "0.2.0"
-source = "git+https://github.com/zkonduit/halo2#d7ecad83c7439fa1cb450ee4a89c2d0b45604ceb"
+source = "git+https://github.com/zkonduit/halo2#f441c920be45f8f05d2c06a173d82e8885a5ed4d"
 dependencies = [
  "arrayvec 0.7.4",
  "bitvec",
@@ -2414,7 +2414,7 @@ dependencies = [
 [[package]]
 name = "halo2_proofs"
 version = "0.3.0"
-source = "git+https://github.com/zkonduit/halo2#bf9d0057a82443be48c4779bbe14961c18fb5996#bf9d0057a82443be48c4779bbe14961c18fb5996"
+source = "git+https://github.com/zkonduit/halo2#f441c920be45f8f05d2c06a173d82e8885a5ed4d#f441c920be45f8f05d2c06a173d82e8885a5ed4d"
 dependencies = [
  "bincode",
  "blake2b_simd",
@@ -3139,7 +3139,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
 dependencies = [
  "cfg-if",
- "windows-targets 0.52.6",
+ "windows-targets 0.48.5",
 ]
 
 [[package]]

Cargo.toml

@@ -276,10 +276,11 @@ macos-metal = ["halo2_proofs/macos"]
 ios-metal = ["halo2_proofs/ios"]
 
 [patch.'https://github.com/zkonduit/halo2']
-halo2_proofs = { git = "https://github.com/zkonduit/halo2#bf9d0057a82443be48c4779bbe14961c18fb5996", package = "halo2_proofs" }
+halo2_proofs = { git = "https://github.com/zkonduit/halo2#f441c920be45f8f05d2c06a173d82e8885a5ed4d", package = "halo2_proofs" }
 
 [patch.'https://github.com/zkonduit/halo2#0654e92bdf725fd44d849bfef3643870a8c7d50b']
-halo2_proofs = { git = "https://github.com/zkonduit/halo2#bf9d0057a82443be48c4779bbe14961c18fb5996", package = "halo2_proofs" }
+halo2_proofs = { git = "https://github.com/zkonduit/halo2#f441c920be45f8f05d2c06a173d82e8885a5ed4d", package = "halo2_proofs" }
+
 
 [patch.crates-io]
 uniffi_testing = { git = "https://github.com/ElusAegis/uniffi-rs", branch = "feat/testing-feature-build-fix" }

examples/onnx/integer_div/gen.py

@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        return x // 3
+
+
+circuit = MyModel()
+
+x = torch.randint(0, 10, (1, 2, 2, 8)) 
+
+out = circuit(x)
+
+print(x)
+print(out)
+print(x/3)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))

examples/onnx/integer_div/input.json

@@ -0,0 +1 @@
+{"input_data": [[3, 4, 0, 9, 2, 6, 2, 5, 1, 5, 3, 5, 5, 7, 0, 2, 6, 1, 4, 4, 1, 9, 7, 7, 5, 8, 2, 0, 1, 5, 9, 8]]}

src/bindings/python.rs

@@ -8,7 +8,6 @@ use crate::circuit::InputType;
 use crate::circuit::{CheckMode, Tolerance};
 use crate::commands::*;
 use crate::fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep};
-use crate::graph::modules::POSEIDON_LEN_GRAPH;
 use crate::graph::TestDataSource;
 use crate::graph::{
     quantize_float, scale_to_multiplier, GraphCircuit, GraphSettings, Model, Visibility,
@@ -578,10 +577,7 @@ fn poseidon_hash(message: Vec<PyFelt>) -> PyResult<Vec<PyFelt>> {
         .map(crate::pfsys::string_to_field::<Fr>)
         .collect::<Vec<_>>();
 
-    let output =
-        PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, POSEIDON_LEN_GRAPH>::run(
-            message.clone(),
-        )
+    let output = PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>::run(message.clone())
         .map_err(|_| PyIOError::new_err("Failed to run poseidon"))?;
 
     let hash = output[0]

src/bindings/wasm.rs

@@ -8,10 +8,7 @@ use crate::{
         Module,
     },
     fieldutils::{felt_to_integer_rep, integer_rep_to_felt},
-    graph::{
-        modules::POSEIDON_LEN_GRAPH, quantize_float, scale_to_multiplier, GraphCircuit,
-        GraphSettings,
-    },
+    graph::{quantize_float, scale_to_multiplier, GraphCircuit, GraphSettings},
 };
 use console_error_panic_hook;
 use halo2_proofs::{
@@ -231,10 +228,7 @@ pub fn poseidonHash(
     let message: Vec<Fr> = serde_json::from_slice(&message[..])
         .map_err(|e| JsError::new(&format!("Failed to deserialize message: {}", e)))?;
 
-    let output =
-        PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, POSEIDON_LEN_GRAPH>::run(
-            message.clone(),
-        )
+    let output = PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>::run(message.clone())
         .map_err(|e| JsError::new(&format!("{}", e)))?;
 
     Ok(wasm_bindgen::Clamped(serde_json::to_vec(&output).map_err(

src/circuit/modules/poseidon.rs

@@ -8,13 +8,11 @@ pub mod poseidon_params;
 pub mod spec;
 
 // This chip adds a set of advice columns to the gadget Chip to store the inputs of the hash
-use halo2_gadgets::poseidon::{primitives::*, Hash, Pow5Chip, Pow5Config};
-use halo2_proofs::arithmetic::Field;
+use halo2_gadgets::poseidon::{
+    primitives::VariableLength, primitives::*, Hash, Pow5Chip, Pow5Config,
+};
 use halo2_proofs::halo2curves::bn256::Fr as Fp;
 use halo2_proofs::{circuit::*, plonk::*};
-// use maybe_rayon::prelude::{IndexedParallelIterator, IntoParallelRefIterator};
-use maybe_rayon::prelude::ParallelIterator;
-use maybe_rayon::slice::ParallelSlice;
 
 use std::marker::PhantomData;
 
@@ -40,22 +38,17 @@ pub struct PoseidonConfig<const WIDTH: usize, const RATE: usize> {
     pub pow5_config: Pow5Config<Fp, WIDTH, RATE>,
 }
 
-type InputAssignments = (Vec<AssignedCell<Fp, Fp>>, AssignedCell<Fp, Fp>);
+type InputAssignments = Vec<AssignedCell<Fp, Fp>>;
 
 /// PoseidonChip is a wrapper around the Pow5Chip that adds a set of advice columns to the gadget Chip to store the inputs of the hash
 #[derive(Debug, Clone)]
-pub struct PoseidonChip<
-    S: Spec<Fp, WIDTH, RATE> + Sync,
-    const WIDTH: usize,
-    const RATE: usize,
-    const L: usize,
-> {
+pub struct PoseidonChip<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize> {
     config: PoseidonConfig<WIDTH, RATE>,
     _marker: PhantomData<S>,
 }
 
-impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, const L: usize>
-    PoseidonChip<S, WIDTH, RATE, L>
+impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize>
+    PoseidonChip<S, WIDTH, RATE>
 {
     /// Creates a new PoseidonChip
     pub fn configure_with_cols(
@@ -82,8 +75,8 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
     }
 }
 
-impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, const L: usize>
-    PoseidonChip<S, WIDTH, RATE, L>
+impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize>
+    PoseidonChip<S, WIDTH, RATE>
 {
     /// Configuration of the PoseidonChip
     pub fn configure_with_optional_instance(
@@ -113,8 +106,8 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
     }
 }
 
-impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, const L: usize>
-    Module<Fp> for PoseidonChip<S, WIDTH, RATE, L>
+impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize> Module<Fp>
+    for PoseidonChip<S, WIDTH, RATE>
 {
     type Config = PoseidonConfig<WIDTH, RATE>;
     type InputAssignments = InputAssignments;
@@ -183,95 +176,81 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
         let res = layouter.assign_region(
             || "load message",
             |mut region| {
-                let assigned_message: Result<Vec<AssignedCell<Fp, Fp>>, ModuleError> =
-                    match &message {
-                        ValTensor::Value { inner: v, .. } => {
-                            v.iter()
-                                .enumerate()
-                                .map(|(i, value)| {
-                                    let x = i % WIDTH;
-                                    let y = i / WIDTH;
+                let assigned_message: Result<Vec<AssignedCell<Fp, Fp>>, _> = match &message {
+                    ValTensor::Value { inner: v, .. } => v
+                        .iter()
+                        .enumerate()
+                        .map(|(i, value)| {
+                            let x = i % WIDTH;
+                            let y = i / WIDTH;
 
-                                    match value {
-                                        ValType::Value(v) => region
-                                            .assign_advice(
-                                                || format!("load message_{}", i),
-                                                self.config.hash_inputs[x],
-                                                y,
-                                                || *v,
-                                            )
-                                            .map_err(|e| e.into()),
-                                        ValType::PrevAssigned(v)
-                                        | ValType::AssignedConstant(v, ..) => Ok(v.clone()),
-                                        ValType::Constant(f) => {
-                                            if local_constants.contains_key(f) {
-                                                Ok(constants
-                                                    .get(f)
-                                                    .unwrap()
-                                                    .assigned_cell()
-                                                    .ok_or(ModuleError::ConstantNotAssigned)?)
-                                            } else {
-                                                let res = region.assign_advice_from_constant(
-                                                    || format!("load message_{}", i),
-                                                    self.config.hash_inputs[x],
-                                                    y,
-                                                    *f,
-                                                )?;
-
-                                                constants.insert(
-                                                    *f,
-                                                    ValType::AssignedConstant(res.clone(), *f),
-                                                );
-
-                                                Ok(res)
-                                            }
-                                        }
-                                        e => Err(ModuleError::WrongInputType(
-                                            format!("{:?}", e),
-                                            "AssignedValue".to_string(),
-                                        )),
-                                    }
-                                })
-                                .collect()
-                        }
-                        ValTensor::Instance {
-                            dims,
-                            inner: col,
-                            idx,
-                            initial_offset,
-                            ..
-                        } => {
-                            // this should never ever fail
-                            let num_elems = dims[*idx].iter().product::<usize>();
-                            (0..num_elems)
-                                .map(|i| {
-                                    let x = i % WIDTH;
-                                    let y = i / WIDTH;
-                                    region.assign_advice_from_instance(
-                                        || "pub input anchor",
-                                        *col,
-                                        initial_offset + i,
+                            match value {
+                                ValType::Value(v) => region
+                                    .assign_advice(
+                                        || format!("load message_{}", i),
                                         self.config.hash_inputs[x],
                                         y,
+                                        || *v,
                                     )
-                                })
-                                .collect::<Result<Vec<_>, _>>()
-                                .map_err(|e| e.into())
-                        }
-                    };
+                                    .map_err(|e| e.into()),
+                                ValType::PrevAssigned(v) | ValType::AssignedConstant(v, ..) => {
+                                    Ok(v.clone())
+                                }
+                                ValType::Constant(f) => {
+                                    if local_constants.contains_key(f) {
+                                        Ok(constants
+                                            .get(f)
+                                            .unwrap()
+                                            .assigned_cell()
+                                            .ok_or(ModuleError::ConstantNotAssigned)?)
+                                    } else {
+                                        let res = region.assign_advice_from_constant(
+                                            || format!("load message_{}", i),
+                                            self.config.hash_inputs[x],
+                                            y,
+                                            *f,
+                                        )?;
 
-                let offset = message.len() / WIDTH + 1;
+                                        constants
+                                            .insert(*f, ValType::AssignedConstant(res.clone(), *f));
 
-                let zero_val = region
-                    .assign_advice_from_constant(
-                        || "",
-                        self.config.hash_inputs[0],
-                        offset,
-                        Fp::ZERO,
-                    )
-                    .unwrap();
+                                        Ok(res)
+                                    }
+                                }
+                                e => Err(ModuleError::WrongInputType(
+                                    format!("{:?}", e),
+                                    "AssignedValue".to_string(),
+                                )),
+                            }
+                        })
+                        .collect(),
+                    ValTensor::Instance {
+                        dims,
+                        inner: col,
+                        idx,
+                        initial_offset,
+                        ..
+                    } => {
+                        // this should never ever fail
+                        let num_elems = dims[*idx].iter().product::<usize>();
+                        (0..num_elems)
+                            .map(|i| {
+                                let x = i % WIDTH;
+                                let y = i / WIDTH;
+                                region.assign_advice_from_instance(
+                                    || "pub input anchor",
+                                    *col,
+                                    initial_offset + i,
+                                    self.config.hash_inputs[x],
+                                    y,
+                                )
+                            })
+                            .collect::<Result<Vec<_>, _>>()
+                            .map_err(|e| e.into())
+                    }
+                };
 
-                Ok((assigned_message?, zero_val))
+                Ok(assigned_message?)
             },
         );
         log::trace!(
@@ -292,7 +271,7 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
         row_offset: usize,
         constants: &mut ConstantsMap<Fp>,
     ) -> Result<ValTensor<Fp>, ModuleError> {
-        let (mut input_cells, zero_val) = self.layout_inputs(layouter, input, constants)?;
+        let input_cells = self.layout_inputs(layouter, input, constants)?;
 
         // empty hash case
         if input_cells.is_empty() {
@@ -306,52 +285,25 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
 
         let start_time = instant::Instant::now();
 
-        let mut one_iter = false;
-        // do the Tree dance baby
-        while input_cells.len() > 1 || !one_iter {
-            let hashes: Result<Vec<AssignedCell<Fp, Fp>>, ModuleError> = input_cells
-                .chunks(L)
-                .enumerate()
-                .map(|(i, block)| {
-                    let _start_time = instant::Instant::now();
+        let pow5_chip = Pow5Chip::construct(self.config.pow5_config.clone());
+        // initialize the hasher
+        let hasher = Hash::<_, _, S, VariableLength, WIDTH, RATE>::init(
+            pow5_chip,
+            layouter.namespace(|| "block_hasher"),
+        )?;
 
-                    let mut block = block.to_vec();
-                    let remainder = block.len() % L;
-
-                    if remainder != 0 {
-                        block.extend(vec![zero_val.clone(); L - remainder]);
-                    }
-
-                    let pow5_chip = Pow5Chip::construct(self.config.pow5_config.clone());
-                    // initialize the hasher
-                    let hasher = Hash::<_, _, S, ConstantLength<L>, WIDTH, RATE>::init(
-                        pow5_chip,
-                        layouter.namespace(|| "block_hasher"),
-                    )?;
-
-                    let hash = hasher.hash(
-                        layouter.namespace(|| "hash"),
-                        block.to_vec().try_into().map_err(|_| Error::Synthesis)?,
-                    );
-
-                    if i == 0 {
-                        log::trace!("block (L={:?}) took: {:?}", L, _start_time.elapsed());
-                    }
-
-                    hash
-                })
-                .collect::<Result<Vec<_>, _>>()
-                .map_err(|e| e.into());
-
-            log::trace!("hashes (N={:?}) took: {:?}", len, start_time.elapsed());
-            one_iter = true;
-            input_cells = hashes?;
-        }
+        let hash: AssignedCell<Fp, Fp> = hasher.hash(
+            layouter.namespace(|| "hash"),
+            input_cells
+                .to_vec()
+                .try_into()
+                .map_err(|_| Error::Synthesis)?,
+        )?;
 
         let duration = start_time.elapsed();
         log::trace!("layout (N={:?}) took: {:?}", len, duration);
 
-        let result = Tensor::from(input_cells.iter().map(|e| ValType::from(e.clone())));
+        let result = Tensor::from(vec![ValType::from(hash.clone())].into_iter());
 
         let output = match result[0].clone() {
             ValType::PrevAssigned(v) => v,
@@ -390,69 +342,59 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
 
     ///
     fn run(message: Vec<Fp>) -> Result<Vec<Vec<Fp>>, ModuleError> {
-        let mut hash_inputs = message;
-
-        let len = hash_inputs.len();
+        let len = message.len();
+        if len == 0 {
+            return Ok(vec![vec![]]);
+        }
 
         let start_time = instant::Instant::now();
 
-        let mut one_iter = false;
-        // do the Tree dance baby
-        while hash_inputs.len() > 1 || !one_iter {
-            let hashes: Vec<Fp> = hash_inputs
-                .par_chunks(L)
-                .map(|block| {
-                    let mut block = block.to_vec();
-                    let remainder = block.len() % L;
-
-                    if remainder != 0 {
-                        block.extend(vec![Fp::ZERO; L - remainder].iter());
-                    }
-
-                    let block_len = block.len();
-
-                    let message = block
-                        .try_into()
-                        .map_err(|_| ModuleError::InputWrongLength(block_len))?;
-
-                    Ok(halo2_gadgets::poseidon::primitives::Hash::<
-                        _,
-                        S,
-                        ConstantLength<L>,
-                        { WIDTH },
-                        { RATE },
-                    >::init()
-                    .hash(message))
-                })
-                .collect::<Result<Vec<_>, ModuleError>>()?;
-            one_iter = true;
-            hash_inputs = hashes;
-        }
+        let hash = halo2_gadgets::poseidon::primitives::Hash::<
+            _,
+            S,
+            VariableLength,
+            { WIDTH },
+            { RATE },
+        >::init()
+        .hash(message);
 
         let duration = start_time.elapsed();
         log::trace!("run (N={:?}) took: {:?}", len, duration);
 
-        Ok(vec![hash_inputs])
+        Ok(vec![vec![hash]])
     }
 
-    fn num_rows(mut input_len: usize) -> usize {
+    fn num_rows(input_len: usize) -> usize {
         // this was determined by running the circuit and looking at the number of constraints
         // in the test called hash_for_a_range_of_input_sizes, then regressing in python to find the slope
-        let fixed_cost: usize = 41 * L;
+        // import numpy as np
+        // from scipy import stats
 
-        let mut num_rows = 0;
+        // x = np.array([32, 64, 96, 128, 160, 192])
+        // y = np.array([1298, 2594, 3890, 5186, 6482, 7778])
 
-        loop {
-            // the number of times the input_len is divisible by L
-            let num_chunks = input_len / L + 1;
-            num_rows += num_chunks * fixed_cost;
-            if num_chunks == 1 {
-                break;
-            }
-            input_len = num_chunks;
-        }
+        // slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)
 
-        num_rows
+        // print(f"slope: {slope}")
+        // print(f"intercept: {intercept}")
+        // print(f"R^2: {r_value**2}")
+
+        // # Predict for any x
+        // def predict(x):
+        // return slope * x + intercept
+
+        // # Test prediction
+        // test_x = 256
+        // print(f"Predicted value for x={test_x}: {predict(test_x)}")
+        // our output:
+        // slope: 40.5
+        // intercept: 2.0
+        // R^2: 1.0
+        // Predicted value for x=256: 10370.0
+        let fixed_cost: usize = 41 * input_len;
+
+        // the cost of the hash function is linear with the number of inputs
+        fixed_cost + 2
     }
 }
 
@@ -479,12 +421,12 @@ mod tests {
     const RATE: usize = POSEIDON_RATE;
     const R: usize = 240;
 
-    struct HashCircuit<S: Spec<Fp, WIDTH, RATE>, const L: usize> {
+    struct HashCircuit<S: Spec<Fp, WIDTH, RATE>> {
         message: ValTensor<Fp>,
         _spec: PhantomData<S>,
     }
 
-    impl<S: Spec<Fp, WIDTH, RATE>, const L: usize> Circuit<Fp> for HashCircuit<S, L> {
+    impl<S: Spec<Fp, WIDTH, RATE>> Circuit<Fp> for HashCircuit<S> {
         type Config = PoseidonConfig<WIDTH, RATE>;
         type FloorPlanner = ModulePlanner;
         type Params = ();
@@ -500,7 +442,7 @@ mod tests {
         }
 
         fn configure(meta: &mut ConstraintSystem<Fp>) -> PoseidonConfig<WIDTH, RATE> {
-            PoseidonChip::<PoseidonSpec, WIDTH, RATE, L>::configure(meta, ())
+            PoseidonChip::<PoseidonSpec, WIDTH, RATE>::configure(meta, ())
         }
 
         fn synthesize(
@@ -508,7 +450,7 @@ mod tests {
             config: PoseidonConfig<WIDTH, RATE>,
             mut layouter: impl Layouter<Fp>,
         ) -> Result<(), Error> {
-            let chip: PoseidonChip<PoseidonSpec, WIDTH, RATE, L> = PoseidonChip::new(config);
+            let chip: PoseidonChip<PoseidonSpec, WIDTH, RATE> = PoseidonChip::new(config);
             chip.layout(
                 &mut layouter,
                 &[self.message.clone()],
@@ -523,15 +465,15 @@ mod tests {
     #[test]
     fn poseidon_hash_empty() {
         let message = [];
-        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE, 2>::run(message.to_vec()).unwrap();
+        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(message.to_vec()).unwrap();
         let mut message: Tensor<ValType<Fp>> =
             message.into_iter().map(|m| Value::known(m).into()).into();
         let k = 9;
-        let circuit = HashCircuit::<PoseidonSpec, 2> {
+        let circuit = HashCircuit::<PoseidonSpec> {
             message: message.into(),
             _spec: PhantomData,
         };
-        let prover = halo2_proofs::dev::MockProver::run(k, &circuit, output).unwrap();
+        let prover = halo2_proofs::dev::MockProver::run(k, &circuit, vec![vec![]]).unwrap();
         assert_eq!(prover.verify(), Ok(()))
     }
 
@@ -540,13 +482,13 @@ mod tests {
         let rng = rand::rngs::OsRng;
 
         let message = [Fp::random(rng), Fp::random(rng)];
-        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE, 2>::run(message.to_vec()).unwrap();
+        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(message.to_vec()).unwrap();
 
         let mut message: Tensor<ValType<Fp>> =
             message.into_iter().map(|m| Value::known(m).into()).into();
 
         let k = 9;
-        let circuit = HashCircuit::<PoseidonSpec, 2> {
+        let circuit = HashCircuit::<PoseidonSpec> {
             message: message.into(),
             _spec: PhantomData,
         };
@@ -559,13 +501,13 @@ mod tests {
         let rng = rand::rngs::OsRng;
 
         let message = [Fp::random(rng), Fp::random(rng), Fp::random(rng)];
-        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE, 3>::run(message.to_vec()).unwrap();
+        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(message.to_vec()).unwrap();
 
         let mut message: Tensor<ValType<Fp>> =
             message.into_iter().map(|m| Value::known(m).into()).into();
 
         let k = 9;
-        let circuit = HashCircuit::<PoseidonSpec, 3> {
+        let circuit = HashCircuit::<PoseidonSpec> {
             message: message.into(),
             _spec: PhantomData,
         };
@@ -581,23 +523,21 @@ mod tests {
         #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
         env_logger::init();
 
-        {
-            let i = 32;
+        for i in (32..128).step_by(32) {
             // print a bunch of new lines
-            println!(
+            log::info!(
                 "i is {} -------------------------------------------------",
                 i
             );
 
             let message: Vec<Fp> = (0..i).map(|_| Fp::random(rng)).collect::<Vec<_>>();
-            let output =
-                PoseidonChip::<PoseidonSpec, WIDTH, RATE, 32>::run(message.clone()).unwrap();
+            let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(message.clone()).unwrap();
 
             let mut message: Tensor<ValType<Fp>> =
                 message.into_iter().map(|m| Value::known(m).into()).into();
 
             let k = 17;
-            let circuit = HashCircuit::<PoseidonSpec, 32> {
+            let circuit = HashCircuit::<PoseidonSpec> {
                 message: message.into(),
                 _spec: PhantomData,
             };
@@ -614,13 +554,13 @@ mod tests {
 
         let mut message: Vec<Fp> = (0..2048).map(|_| Fp::random(rng)).collect::<Vec<_>>();
 
-        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE, 25>::run(message.clone()).unwrap();
+        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(message.clone()).unwrap();
 
         let mut message: Tensor<ValType<Fp>> =
             message.into_iter().map(|m| Value::known(m).into()).into();
 
         let k = 17;
-        let circuit = HashCircuit::<PoseidonSpec, 25> {
+        let circuit = HashCircuit::<PoseidonSpec> {
             message: message.into(),
             _spec: PhantomData,
         };

src/circuit/ops/layouts.rs

@@ -157,7 +157,9 @@ pub(crate) fn div<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
     // 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 {
+    if F::from_u128(IntegerRep::MAX as u128)
+        < F::from_u128(region.base() as u128).pow([region.legs() as u64]) - F::ONE
+    {
         // here we decompose and extract the sign of the input
         let sign = sign(config, region, &[claimed_output.clone()])?;
 
@@ -254,7 +256,9 @@ pub(crate) fn recip<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
     )?;
 
     // 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 {
+    if F::from_u128(IntegerRep::MAX as u128)
+        < F::from_u128(region.base() as u128).pow([region.legs() as u64]) - F::ONE
+    {
         // here we decompose and extract the sign of the input
         let sign = sign(config, region, &[masked_output.clone()])?;
         let abs_value = pairwise(
@@ -2652,9 +2656,9 @@ pub fn mean_of_squares_axes<F: PrimeField + TensorType + PartialOrd + std::hash:
     let squared = pow(config, region, values, 2)?;
     let sum_squared = sum_axes(config, region, &[squared], axes)?;
 
-    let dividand: usize = values[0].len() / sum_squared.len();
+    let dividend: usize = values[0].len() / sum_squared.len();
 
-    let mean_squared = div(config, region, &[sum_squared], F::from(dividand as u64))?;
+    let mean_squared = div(config, region, &[sum_squared], F::from(dividend as u64))?;
     Ok(mean_squared)
 }
 

src/circuit/tests.rs

@@ -1999,7 +1999,7 @@ mod add_with_overflow_and_poseidon {
             let base = BaseConfig::configure(cs, &[a, b], &output, CheckMode::SAFE);
             VarTensor::constant_cols(cs, K, 2, false);
 
-            let poseidon = PoseidonChip::<PoseidonSpec, WIDTH, RATE, WIDTH>::configure(cs, ());
+            let poseidon = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::configure(cs, ());
 
             MyCircuitConfig { base, poseidon }
         }
@@ -2009,7 +2009,7 @@ mod add_with_overflow_and_poseidon {
             mut config: Self::Config,
             mut layouter: impl Layouter<Fr>,
         ) -> Result<(), Error> {
-            let poseidon_chip: PoseidonChip<PoseidonSpec, WIDTH, RATE, WIDTH> =
+            let poseidon_chip: PoseidonChip<PoseidonSpec, WIDTH, RATE> =
                 PoseidonChip::new(config.poseidon.clone());
 
             let assigned_inputs_a =
@@ -2044,11 +2044,9 @@ mod add_with_overflow_and_poseidon {
         let b = (0..LEN)
             .map(|i| halo2curves::bn256::Fr::from(i as u64 + 1))
             .collect::<Vec<_>>();
-        let commitment_a =
-            PoseidonChip::<PoseidonSpec, WIDTH, RATE, WIDTH>::run(a.clone()).unwrap()[0][0];
+        let commitment_a = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(a.clone()).unwrap()[0][0];
 
-        let commitment_b =
-            PoseidonChip::<PoseidonSpec, WIDTH, RATE, WIDTH>::run(b.clone()).unwrap()[0][0];
+        let commitment_b = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(b.clone()).unwrap()[0][0];
 
         // parameters
         let a = Tensor::from(a.into_iter().map(Value::known));
@@ -2070,13 +2068,11 @@ mod add_with_overflow_and_poseidon {
         let b = (0..LEN)
             .map(|i| halo2curves::bn256::Fr::from(i as u64 + 1))
             .collect::<Vec<_>>();
-        let commitment_a = PoseidonChip::<PoseidonSpec, WIDTH, RATE, WIDTH>::run(a.clone())
-            .unwrap()[0][0]
-            + Fr::one();
+        let commitment_a =
+            PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(a.clone()).unwrap()[0][0] + Fr::one();
 
-        let commitment_b = PoseidonChip::<PoseidonSpec, WIDTH, RATE, WIDTH>::run(b.clone())
-            .unwrap()[0][0]
-            + Fr::one();
+        let commitment_b =
+            PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(b.clone()).unwrap()[0][0] + Fr::one();
 
         // parameters
         let a = Tensor::from(a.into_iter().map(Value::known));

src/graph/modules.rs

@@ -14,14 +14,11 @@ use serde::{Deserialize, Serialize};
 use super::errors::GraphError;
 use super::{VarVisibility, Visibility};
 
-/// poseidon len to hash in tree
-pub const POSEIDON_LEN_GRAPH: usize = 32;
 /// Poseidon number of instances
 pub const POSEIDON_INSTANCES: usize = 1;
 
 /// Poseidon module type
-pub type ModulePoseidon =
-    PoseidonChip<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, POSEIDON_LEN_GRAPH>;
+pub type ModulePoseidon = PoseidonChip<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>;
 /// Poseidon module config
 pub type ModulePoseidonConfig = PoseidonConfig<POSEIDON_WIDTH, POSEIDON_RATE>;
 

src/graph/utilities.rs

@@ -274,11 +274,9 @@ pub fn new_op_from_onnx(
     symbol_values: &SymbolValues,
     run_args: &crate::RunArgs,
 ) -> Result<(SupportedOp, Vec<usize>), GraphError> {
-    use std::f64::consts::E;
-
-    use tract_onnx::tract_core::ops::array::Trilu;
-
     use crate::circuit::InputType;
+    use std::f64::consts::E;
+    use tract_onnx::tract_core::ops::array::Trilu;
 
     let input_scales = inputs
         .iter()
@@ -1274,9 +1272,19 @@ pub fn new_op_from_onnx(
                     // get the non constant index
                     let denom = c.raw_values[0];
 
-                    SupportedOp::Hybrid(HybridOp::Div {
+                    let op = SupportedOp::Hybrid(HybridOp::Div {
                         denom: denom.into(),
-                    })
+                    });
+
+                    // if the input is scale 0 we re up to the max scale
+                    if input_scales[0] == 0 {
+                        SupportedOp::Rescaled(Rescaled {
+                            inner: Box::new(op),
+                            scale: vec![(0, scale_to_multiplier(scales.get_max()) as u128)],
+                        })
+                    } else {
+                        op
+                    }
                 } else {
                     return Err(GraphError::MisformedParams(
                         "only support non zero divisors of size 1".to_string(),

tests/integration_tests.rs

@@ -206,7 +206,7 @@ mod native_tests {
         "1l_tiny_div",
     ];
 
-    const TESTS: [&str; 98] = [
+    const TESTS: [&str; 99] = [
         "1l_mlp",     //0
         "1l_slice",   //1
         "1l_concat",  //2
@@ -309,6 +309,7 @@ mod native_tests {
         "log",         // 95
         "exp",         // 96
         "general_exp", // 97
+        "integer_div", // 98
     ];
 
     const WASM_TESTS: [&str; 46] = [
@@ -547,7 +548,7 @@ mod native_tests {
             }
         });
 
-            seq!(N in 0..=97 {
+            seq!(N in 0..=98 {
 
             #(#[test_case(TESTS[N])])*
             #[ignore]

tests/python/binding_tests.py

@@ -59,7 +59,7 @@ def test_poseidon_hash():
     message = [ezkl.float_to_felt(x, 7) for x in message]
     res = ezkl.poseidon_hash(message)
     assert ezkl.felt_to_big_endian(
-        res[0]) == "0x0da7e5e5c8877242fa699f586baf770d731defd54f952d4adeb85047a0e32f45"
+        res[0]) == "0x2369898875588bf49b6539376b09705ea69aee318a58e6fcc1e68fc3e7ad81ab"
 
 
 

tests/wasm.rs

@@ -11,7 +11,6 @@ mod wasm32 {
     use ezkl::circuit::modules::poseidon::spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH};
     use ezkl::circuit::modules::poseidon::PoseidonChip;
     use ezkl::circuit::modules::Module;
-    use ezkl::graph::modules::POSEIDON_LEN_GRAPH;
     use ezkl::graph::GraphCircuit;
     use ezkl::graph::{GraphSettings, GraphWitness};
     use ezkl::pfsys;
@@ -227,11 +226,9 @@ mod wasm32 {
         let hash: Vec<Vec<Fr>> = serde_json::from_slice(&hash[..]).unwrap();
 
         let reference_hash =
-            PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, POSEIDON_LEN_GRAPH>::run(
-                message.clone(),
-            )
-            .map_err(|_| "failed")
-            .unwrap();
+            PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>::run(message.clone())
+                .map_err(|_| "failed")
+                .unwrap();
 
         assert_eq!(hash, reference_hash)
     }