ci: update version string in docs

* Improve clarity of an info!() message

* Replace references to EZKL_REPO_PATH in `--help' output

Command `--help' messages aren't meant to be unduly verbose; we can
write them for common/simple use cases. We continue to support
EZKL_REPO_PATH for users who need it, for example to support
containerized server use cases.

To be clear, by default, EZKL_REPO_PATH = $HOME/.ezkl

docs/python/requirements-docs.txt

@@ -1,4 +1,4 @@
-ezkl==15.1.2
+ezkl==15.4.1
 sphinx
 sphinx-rtd-theme
 sphinxcontrib-napoleon

docs/python/src/conf.py

@@ -1,7 +1,7 @@
 import ezkl
 
 project = 'ezkl'
-release = '15.1.2'
+release = '15.4.1'
 version = release
 
 

examples/notebooks/data_attest.ipynb

@@ -592,7 +592,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.12.2"
+            "version": "3.12.5"
         },
         "orig_nbformat": 4
     },

examples/notebooks/data_attest_hashed.ipynb

@@ -648,10 +648,10 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.5"
         },
         "orig_nbformat": 4
     },
     "nbformat": 4,
     "nbformat_minor": 2
-}
+}

examples/notebooks/logistic_regression.ipynb

@@ -271,7 +271,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.12.2"
+            "version": "3.12.7"
         }
     },
     "nbformat": 4,

examples/onnx/log/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):          
+        m = torch.log(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 3)
+
+out = circuit(x)
+
+print(out)
+
+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/log/input.json

@@ -0,0 +1 @@
+{"input_data": [[1.9252371788024902, 1.8418371677398682, 0.8400403261184692, 2.083845853805542, 0.9760497808456421, 0.6940176486968994, 0.015579521656036377, 2.2689192295074463]]}

examples/onnx/log/network.onnx

@@ -0,0 +1,14 @@
+pytorch2.2.2:o
+
+inputoutput/Log"Log
+main_graphZ!
+input
+

+
+batch_size
+b"
+output
+

+
+batch_size
+B

examples/onnx/rounding_ops/gen.py

@@ -21,9 +21,9 @@ def main():
     torch_model = Circuit()
     # Input to the model
     shape = [3, 2, 3]
-    w = 0.1*torch.rand(1, *shape, requires_grad=True)
-    x = 0.1*torch.rand(1, *shape, requires_grad=True)
-    y = 0.1*torch.rand(1, *shape, requires_grad=True)
+    w = 2 * torch.rand(1, *shape, requires_grad=True) - 1
+    x = 2 * torch.rand(1, *shape, requires_grad=True) - 1
+    y = 2 * torch.rand(1, *shape, requires_grad=True) - 1
     torch_out = torch_model(w, x, y)
     # Export the model
     torch.onnx.export(torch_model,               # model being run

examples/onnx/rounding_ops/input.json

@@ -1 +1,148 @@
-{"input_shapes": [[3, 2, 3], [3, 2, 3], [3, 2, 3], [3, 2, 3]], "input_data": [[0.0025284828152507544, 0.04976580664515495, 0.025840921327471733, 0.0829394981265068, 0.09595223516225815, 0.08764562010765076, 0.06308566778898239, 0.062386948615312576, 0.08090643584728241, 0.09267748892307281, 0.07428313046693802, 0.08987367898225784, 0.005716216750442982, 0.0666426345705986, 0.012837404385209084, 0.05769496038556099, 0.05761152133345604, 0.08006472885608673], [0.007834953255951405, 0.011380612850189209, 0.08560049533843994, 0.022283583879470825, 0.07879520952701569, 0.04422441124916077, 0.030812596902251244, 0.006081616971641779, 0.011045408435165882, 0.08776585012674332, 0.044985152781009674, 0.015603715553879738, 0.07923348993062973, 0.04872611165046692, 0.0036642670165747404, 0.05142095685005188, 0.0963878259062767, 0.03225792199373245], [0.09952805936336517, 0.002214533044025302, 0.011696457862854004, 0.022422820329666138, 0.04151459410786629, 0.027647346258163452, 0.011919880285859108, 0.006539052817970514, 0.06569185107946396, 0.034328874200582504, 0.0032284557819366455, 0.004105025436729193, 0.022395813837647438, 0.07135921716690063, 0.07882415503263474, 0.09764843434095383, 0.05335796996951103, 0.0525360181927681]], "output_data": [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]]}
+{
+    "input_shapes": [
+        [
+            3,
+            2,
+            3
+        ],
+        [
+            3,
+            2,
+            3
+        ],
+        [
+            3,
+            2,
+            3
+        ],
+        [
+            3,
+            2,
+            3
+        ]
+    ],
+    "input_data": [
+        [
+            0.5,
+            1.5,
+            -0.04514765739440918,
+            0.5936200618743896,
+            0.9271858930587769,
+            0.6688600778579712,
+            -0.20331168174743652,
+            -0.7016235589981079,
+            0.025863051414489746,
+            -0.19426143169403076,
+            0.9827852249145508,
+            0.4897397756576538,
+            -1.5,
+            -0.5,
+            0.9278832674026489,
+            0.5943725109100342,
+            -0.573331356048584,
+            0.3675816059112549
+        ],
+        [
+            0.7803324460983276,
+            -0.9616303443908691,
+            0.6070173978805542,
+            -0.028337717056274414,
+            -0.5080242156982422,
+            -0.9280107021331787,
+            0.6150380373001099,
+            0.3865993022918701,
+            -0.43668973445892334,
+            0.17152702808380127,
+            0.5144252777099609,
+            -0.28881049156188965,
+            0.8932310342788696,
+            0.059034109115600586,
+            0.6865451335906982,
+            0.009820222854614258,
+            0.23011493682861328,
+            -0.9492779970169067
+        ],
+        [
+            -0.21352827548980713,
+            -0.16015326976776123,
+            -0.38964390754699707,
+            0.13464701175689697,
+            -0.8814496994018555,
+            0.5037975311279297,
+            -0.804405927658081,
+            0.9858957529067993,
+            0.19567716121673584,
+            0.9777265787124634,
+            0.6151977777481079,
+            0.568595290184021,
+            0.10584986209869385,
+            -0.8975653648376465,
+            0.6235959529876709,
+            -0.547879695892334,
+            0.9289869070053101,
+            0.7567293643951416
+        ]
+    ],
+    "output_data": [
+        [
+            1.0,
+            0.0,
+            -0.0,
+            1.0,
+            1.0,
+            1.0,
+            -0.0,
+            -1.0,
+            0.0,
+            -0.0,
+            1.0,
+            0.0,
+            0.0,
+            1.0,
+            1.0,
+            1.0,
+            -1.0,
+            0.0
+        ],
+        [
+            0.0,
+            -1.0,
+            0.0,
+            -1.0,
+            -1.0,
+            -1.0,
+            0.0,
+            0.0,
+            -1.0,
+            0.0,
+            0.0,
+            -1.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            -1.0
+        ],
+        [
+            -0.0,
+            -0.0,
+            -0.0,
+            1.0,
+            -0.0,
+            1.0,
+            -0.0,
+            1.0,
+            1.0,
+            1.0,
+            1.0,
+            1.0,
+            1.0,
+            -0.0,
+            1.0,
+            -0.0,
+            1.0,
+            1.0
+        ]
+    ]
+}

examples/onnx/rounding_ops/network.onnx

@@ -1,10 +1,11 @@
-pytorch2.0.1:â
+pytorch2.2.2:ă
 
 
woutput_w/Round"Round
 
 
xoutput_x/Floor"Floor
 
-
youtput_y/Ceil"Ceil	torch_jitZ%
+
youtput_y/Ceil"Ceil
+main_graphZ%
 
w 
 

 

src/bindings/python.rs

@@ -197,6 +197,9 @@ struct PyRunArgs {
     /// int: The number of legs used for decomposition
     #[pyo3(get, set)]
     pub decomp_legs: usize,
+    /// bool: Should the circuit use unbounded lookups for log
+    #[pyo3(get, set)]
+    pub bounded_log_lookup: bool,
 }
 
 /// default instantiation of PyRunArgs
@@ -212,6 +215,7 @@ impl PyRunArgs {
 impl From<PyRunArgs> for RunArgs {
     fn from(py_run_args: PyRunArgs) -> Self {
         RunArgs {
+            bounded_log_lookup: py_run_args.bounded_log_lookup,
             tolerance: Tolerance::from(py_run_args.tolerance),
             input_scale: py_run_args.input_scale,
             param_scale: py_run_args.param_scale,
@@ -236,6 +240,7 @@ impl From<PyRunArgs> for RunArgs {
 impl Into<PyRunArgs> for RunArgs {
     fn into(self) -> PyRunArgs {
         PyRunArgs {
+            bounded_log_lookup: self.bounded_log_lookup,
             tolerance: self.tolerance.val,
             input_scale: self.input_scale,
             param_scale: self.param_scale,

src/circuit/ops/hybrid.rs

@@ -13,6 +13,26 @@ use serde::{Deserialize, Serialize};
 /// An enum representing the operations that consist of both lookups and arithmetic operations.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum HybridOp {
+    Ln {
+        scale: utils::F32,
+    },
+
+    RoundHalfToEven {
+        scale: utils::F32,
+        legs: usize,
+    },
+    Ceil {
+        scale: utils::F32,
+        legs: usize,
+    },
+    Floor {
+        scale: utils::F32,
+        legs: usize,
+    },
+    Round {
+        scale: utils::F32,
+        legs: usize,
+    },
     Recip {
         input_scale: utils::F32,
         output_scale: utils::F32,
@@ -96,6 +116,14 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
 
     fn as_string(&self) -> String {
         match self {
+            HybridOp::Ln { scale } => format!("LN(scale={})", scale),
+            HybridOp::RoundHalfToEven { scale, legs } => {
+                format!("ROUND_HALF_TO_EVEN(scale={}, legs={})", scale, legs)
+            }
+            HybridOp::Ceil { scale, legs } => format!("CEIL(scale={}, legs={})", scale, legs),
+            HybridOp::Floor { scale, legs } => format!("FLOOR(scale={}, legs={})", scale, legs),
+            HybridOp::Round { scale, legs } => format!("ROUND(scale={}, legs={})", scale, legs),
+
             HybridOp::Max => format!("MAX"),
             HybridOp::Min => format!("MIN"),
             HybridOp::Recip {
@@ -166,6 +194,19 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
         values: &[ValTensor<F>],
     ) -> Result<Option<ValTensor<F>>, CircuitError> {
         Ok(Some(match self {
+            HybridOp::Ln { scale } => layouts::ln(config, region, values[..].try_into()?, *scale)?,
+            HybridOp::RoundHalfToEven { scale, legs } => {
+                layouts::round_half_to_even(config, region, values[..].try_into()?, *scale, *legs)?
+            }
+            HybridOp::Ceil { scale, legs } => {
+                layouts::ceil(config, region, values[..].try_into()?, *scale, *legs)?
+            }
+            HybridOp::Floor { scale, legs } => {
+                layouts::floor(config, region, values[..].try_into()?, *scale, *legs)?
+            }
+            HybridOp::Round { scale, legs } => {
+                layouts::round(config, region, values[..].try_into()?, *scale, *legs)?
+            }
             HybridOp::Max => layouts::max_comp(config, region, values[..].try_into()?)?,
             HybridOp::Min => layouts::min_comp(config, region, values[..].try_into()?)?,
             HybridOp::SumPool {
@@ -292,6 +333,9 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
             HybridOp::Softmax { output_scale, .. } | HybridOp::Recip { output_scale, .. } => {
                 multiplier_to_scale(output_scale.0 as f64)
             }
+            HybridOp::Ln {
+                scale: output_scale,
+            } => 4 * multiplier_to_scale(output_scale.0 as f64),
             _ => in_scales[0],
         };
         Ok(scale)

src/circuit/ops/layouts.rs

@@ -4155,8 +4155,40 @@ pub(crate) fn argmin<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
     Ok(assigned_argmin)
 }
 
-/// max layout
-pub(crate) fn max_comp<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
+/// Max layout
+/// # Arguments
+/// * `config` - BaseConfig
+/// * `region` - RegionCtx
+/// * `values` - &[ValTensor<F>; 2]
+/// # Returns
+/// * ValTensor<F>
+/// # Example
+/// ```
+/// use ezkl::tensor::Tensor;
+/// use ezkl::fieldutils::IntegerRep;
+/// use ezkl::circuit::ops::layouts::max_comp;
+/// use ezkl::tensor::val::ValTensor;
+/// use halo2curves::bn256::Fr as Fp;
+/// use ezkl::circuit::region::RegionCtx;
+/// use ezkl::circuit::region::RegionSettings;
+/// use ezkl::circuit::BaseConfig;
+/// let dummy_config = BaseConfig::dummy(12, 2);
+/// let mut dummy_region = RegionCtx::new_dummy(0,2,RegionSettings::all_true(128,2));
+/// let x = ValTensor::from_integer_rep_tensor(Tensor::<IntegerRep>::new(
+///    Some(&[5, 2, 3, 0]),
+///   &[1, 1, 2, 2],
+/// ).unwrap());
+/// let y = ValTensor::from_integer_rep_tensor(Tensor::<IntegerRep>::new(
+///   Some(&[5, 1, 1, 1]),
+///  &[1, 1, 2, 2],
+/// ).unwrap());
+///
+/// let result = max_comp::<Fp>(&dummy_config, &mut dummy_region, &[x, y]).unwrap();
+/// let expected = Tensor::<IntegerRep>::new(Some(&[5, 2, 3, 1]), &[1, 1, 2, 2]).unwrap();
+/// assert_eq!(result.int_evals().unwrap(), expected);
+/// ```
+///
+pub fn max_comp<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
     config: &BaseConfig<F>,
     region: &mut RegionCtx<F>,
     values: &[ValTensor<F>; 2],
@@ -4176,8 +4208,38 @@ pub(crate) fn max_comp<F: PrimeField + TensorType + PartialOrd + std::hash::Hash
     pairwise(config, region, &[max_val_p1, max_val_p2], BaseOp::Add)
 }
 
-/// min comp layout
-pub(crate) fn min_comp<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
+/// Min comp layout
+/// # Arguments
+/// * `config` - BaseConfig
+/// * `region` - RegionCtx
+/// * `values` - &[ValTensor<F>; 2]
+/// # Returns
+/// * ValTensor<F>
+/// # Example
+/// ```
+/// use ezkl::tensor::Tensor;
+/// use ezkl::fieldutils::IntegerRep;
+/// use ezkl::circuit::ops::layouts::min_comp;
+/// use ezkl::tensor::val::ValTensor;
+/// use halo2curves::bn256::Fr as Fp;
+/// use ezkl::circuit::region::RegionCtx;
+/// use ezkl::circuit::region::RegionSettings;
+/// use ezkl::circuit::BaseConfig;
+/// let dummy_config = BaseConfig::dummy(12, 2);
+/// let mut dummy_region = RegionCtx::new_dummy(0,2,RegionSettings::all_true(128,2));
+/// let x = ValTensor::from_integer_rep_tensor(Tensor::<IntegerRep>::new(
+///   Some(&[5, 2, 3, 0]),
+///  &[1, 1, 2, 2],
+/// ).unwrap());
+/// let y = ValTensor::from_integer_rep_tensor(Tensor::<IntegerRep>::new(
+///  Some(&[5, 1, 1, 1]),
+/// &[1, 1, 2, 2],
+/// ).unwrap());
+/// let result = min_comp::<Fp>(&dummy_config, &mut dummy_region, &[x, y]).unwrap();
+/// let expected = Tensor::<IntegerRep>::new(Some(&[5, 1, 1, 0]), &[1, 1, 2, 2]).unwrap();
+/// assert_eq!(result.int_evals().unwrap(), expected);
+/// ```
+pub fn min_comp<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
     config: &BaseConfig<F>,
     region: &mut RegionCtx<F>,
     values: &[ValTensor<F>; 2],
@@ -4220,6 +4282,913 @@ pub(crate) fn min<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
         .map_err(|e| e.into())
 }
 
+/// floor layout
+/// # Arguments
+/// * `config` - BaseConfig
+/// * `region` - RegionCtx
+/// * `values` - &[ValTensor<F>; 1]
+/// * `scale` - utils::F32
+/// * `legs` - usize
+/// # Returns
+/// * ValTensor<F>
+/// # Example
+/// ```
+/// use ezkl::tensor::Tensor;
+/// use ezkl::fieldutils::IntegerRep;
+/// use ezkl::circuit::ops::layouts::floor;
+/// use ezkl::tensor::val::ValTensor;
+/// use halo2curves::bn256::Fr as Fp;
+/// use ezkl::circuit::region::RegionCtx;
+/// use ezkl::circuit::region::RegionSettings;
+/// use ezkl::circuit::BaseConfig;
+/// let dummy_config = BaseConfig::dummy(12, 2);
+/// let mut dummy_region = RegionCtx::new_dummy(0,2,RegionSettings::all_true(128,2));
+/// let x = ValTensor::from_integer_rep_tensor(Tensor::<IntegerRep>::new(
+/// Some(&[3, -2, -3, 1]),
+/// &[1, 1, 2, 2],
+/// ).unwrap());
+/// let result = floor::<Fp>(&dummy_config, &mut dummy_region, &[x], 2.0.into(), 2).unwrap();
+/// let expected = Tensor::<IntegerRep>::new(Some(&[2, -2, -4, 0]), &[1, 1, 2, 2]).unwrap();
+/// assert_eq!(result.int_evals().unwrap(), expected);
+/// ```
+pub fn floor<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
+    config: &BaseConfig<F>,
+    region: &mut RegionCtx<F>,
+    values: &[ValTensor<F>; 1],
+    scale: utils::F32,
+    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)?;
+    // 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);
+
+    let negative_one = create_constant_tensor(integer_rep_to_felt(-1), 1);
+    let assigned_negative_one = region.assign(&config.custom_gates.inputs[1], &negative_one)?;
+
+    region.increment(1);
+
+    let dims = decomposition.dims().to_vec();
+    let first_dims = decomposition.dims().to_vec()[..decomposition.dims().len() - 1].to_vec();
+
+    let mut incremented_tensor = Tensor::new(None, &first_dims)?;
+
+    let cartesian_coord = first_dims
+        .iter()
+        .map(|x| 0..*x)
+        .multi_cartesian_product()
+        .collect::<Vec<_>>();
+
+    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 = decomposition.get_slice(&slice)?;
+            sliced_input.flatten();
+            let last_elem = sliced_input.last()?;
+
+            let last_elem_is_zero = equals_zero(config, region, &[last_elem.clone()])?;
+            let last_elem_is_not_zero = not(config, region, &[last_elem_is_zero.clone()])?;
+
+            let sign = sliced_input.first()?;
+            let is_negative = equals(config, region, &[sign, assigned_negative_one.clone()])?;
+
+            let is_negative_and_not_zero = and(
+                config,
+                region,
+                &[last_elem_is_not_zero.clone(), is_negative.clone()],
+            )?;
+
+            // increment the penultimate element
+            let incremented_elem = pairwise(
+                config,
+                region,
+                &[
+                    sliced_input.get_slice(&[sliced_input.len() - 2..sliced_input.len() - 1])?,
+                    is_negative_and_not_zero.clone(),
+                ],
+                BaseOp::Add,
+            )?;
+
+            let mut inner_tensor = sliced_input.get_inner_tensor()?.clone();
+            inner_tensor[sliced_input.len() - 2] =
+                incremented_elem.get_inner_tensor()?.clone()[0].clone();
+
+            // set the last elem to zero
+            inner_tensor[sliced_input.len() - 1] = zero.clone();
+
+            Ok(inner_tensor.clone())
+        };
+
+    region.apply_in_loop(&mut incremented_tensor, inner_loop_function)?;
+
+    let mut incremented_tensor = incremented_tensor.combine()?;
+    incremented_tensor.reshape(&dims)?;
+
+    recompose(
+        config,
+        region,
+        &[incremented_tensor.into()],
+        &(scale.0 as usize),
+    )
+}
+
+/// ceil layout
+/// # Arguments
+/// * `config` - BaseConfig
+/// * `region` - RegionCtx
+/// * `values` - &[ValTensor<F>; 1]
+/// * `scale` - utils::F32
+/// * `legs` - usize
+/// # Returns
+/// * ValTensor<F>
+/// # Example
+/// ```
+/// use ezkl::tensor::Tensor;
+/// use ezkl::fieldutils::IntegerRep;
+/// use ezkl::circuit::ops::layouts::ceil;
+/// use ezkl::tensor::val::ValTensor;
+/// use halo2curves::bn256::Fr as Fp;
+/// use ezkl::circuit::region::RegionCtx;
+/// use ezkl::circuit::region::RegionSettings;
+/// use ezkl::circuit::BaseConfig;
+/// let dummy_config = BaseConfig::dummy(12, 2);
+/// let mut dummy_region = RegionCtx::new_dummy(0,2,RegionSettings::all_true(128,2));
+/// let x = ValTensor::from_integer_rep_tensor(Tensor::<IntegerRep>::new(
+///  Some(&[3, -2, 3, 1]),
+/// &[1, 1, 2, 2],
+/// ).unwrap());
+/// let result = ceil::<Fp>(&dummy_config, &mut dummy_region, &[x], 2.0.into(), 2).unwrap();
+/// let expected = Tensor::<IntegerRep>::new(Some(&[4, -2, 4, 2]), &[1, 1, 2, 2]).unwrap();
+/// assert_eq!(result.int_evals().unwrap(), expected);
+/// ```
+///
+pub fn ceil<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
+    config: &BaseConfig<F>,
+    region: &mut RegionCtx<F>,
+    values: &[ValTensor<F>; 1],
+    scale: utils::F32,
+    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)?;
+    // 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);
+
+    let one = create_constant_tensor(integer_rep_to_felt(1), 1);
+    let assigned_one = region.assign(&config.custom_gates.inputs[1], &one)?;
+
+    region.increment(1);
+
+    let dims = decomposition.dims().to_vec();
+    let first_dims = decomposition.dims().to_vec()[..decomposition.dims().len() - 1].to_vec();
+
+    let mut incremented_tensor = Tensor::new(None, &first_dims)?;
+
+    let cartesian_coord = first_dims
+        .iter()
+        .map(|x| 0..*x)
+        .multi_cartesian_product()
+        .collect::<Vec<_>>();
+
+    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 = decomposition.get_slice(&slice)?;
+            sliced_input.flatten();
+            let last_elem = sliced_input.last()?;
+
+            let last_elem_is_zero = equals_zero(config, region, &[last_elem.clone()])?;
+            let last_elem_is_not_zero = not(config, region, &[last_elem_is_zero.clone()])?;
+
+            let sign = sliced_input.first()?;
+            let is_positive = equals(config, region, &[sign, assigned_one.clone()])?;
+
+            let is_positive_and_not_zero = and(
+                config,
+                region,
+                &[last_elem_is_not_zero.clone(), is_positive.clone()],
+            )?;
+
+            // increment the penultimate element
+            let incremented_elem = pairwise(
+                config,
+                region,
+                &[
+                    sliced_input.get_slice(&[sliced_input.len() - 2..sliced_input.len() - 1])?,
+                    is_positive_and_not_zero.clone(),
+                ],
+                BaseOp::Add,
+            )?;
+
+            let mut inner_tensor = sliced_input.get_inner_tensor()?.clone();
+            inner_tensor[sliced_input.len() - 2] =
+                incremented_elem.get_inner_tensor()?.clone()[0].clone();
+
+            // set the last elem to zero
+            inner_tensor[sliced_input.len() - 1] = zero.clone();
+
+            Ok(inner_tensor.clone())
+        };
+
+    region.apply_in_loop(&mut incremented_tensor, inner_loop_function)?;
+
+    let mut incremented_tensor = incremented_tensor.combine()?;
+    incremented_tensor.reshape(&dims)?;
+
+    recompose(
+        config,
+        region,
+        &[incremented_tensor.into()],
+        &(scale.0 as usize),
+    )
+}
+
+/// integer ln layout
+/// # Arguments
+/// * `config` - BaseConfig
+/// * `region` - RegionCtx
+/// * `values` - &[ValTensor<F>; 1]
+/// * `scale` - utils::F32
+/// # Returns
+/// * ValTensor<F>
+/// # Example
+///
+/// ```
+/// use ezkl::tensor::Tensor;
+/// use ezkl::fieldutils::IntegerRep;
+/// use ezkl::circuit::ops::layouts::ln;
+/// use ezkl::tensor::val::ValTensor;
+/// use halo2curves::bn256::Fr as Fp;
+/// use ezkl::circuit::region::RegionCtx;
+/// use ezkl::circuit::region::RegionSettings;
+/// use ezkl::circuit::BaseConfig;
+/// let dummy_config = BaseConfig::dummy(12, 2);
+/// let mut dummy_region = RegionCtx::new_dummy(0,2,RegionSettings::all_true(128,2));
+/// let x = ValTensor::from_integer_rep_tensor(Tensor::<IntegerRep>::new(
+/// Some(&[3, 2, 3, 1]),
+/// &[1, 1, 2, 2],
+/// ).unwrap());
+///
+/// let result = ln::<Fp>(&dummy_config, &mut dummy_region, &[x], 2.0.into()).unwrap();
+/// let expected = Tensor::<IntegerRep>::new(Some(&[4, 0, 4, -8]), &[1, 1, 2, 2]).unwrap();
+/// assert_eq!(result.int_evals().unwrap(), expected);
+///
+/// ```
+pub fn ln<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
+    config: &BaseConfig<F>,
+    region: &mut RegionCtx<F>,
+    values: &[ValTensor<F>; 1],
+    scale: utils::F32,
+) -> Result<ValTensor<F>, CircuitError> {
+    // first generate the claimed val
+
+    let mut input = values[0].clone();
+
+    println!("input {}", input.show());
+
+    let scale_as_felt = integer_rep_to_felt(scale.0.round() as IntegerRep);
+
+    let assigned_triple_scaled_as_felt_tensor = region.assign(
+        &config.custom_gates.inputs[1],
+        &create_constant_tensor(scale_as_felt * scale_as_felt * scale_as_felt, 1),
+    )?;
+
+    // natural ln is log2(x) * ln(2)
+    let ln2 = utils::F32::from(2.0_f32.ln());
+    // now create a constant tensor for ln2 with scale
+    let ln2_tensor: ValTensor<F> = create_constant_tensor(
+        integer_rep_to_felt((ln2.0 * scale.0).round() as IntegerRep),
+        1,
+    );
+    region.assign(&config.custom_gates.inputs[0], &ln2_tensor)?;
+    let unit = create_constant_tensor(integer_rep_to_felt(1), 1);
+    region.assign(&config.custom_gates.inputs[1], &unit)?;
+    region.increment(1);
+
+    // 2. assign the image
+    if !input.all_prev_assigned() {
+        input = region.assign(&config.custom_gates.inputs[0], &input)?;
+        // don't need to increment because the claimed output is assigned to output and incremented accordingly
+    }
+
+    let is_assigned = !input.any_unknowns()?;
+
+    let mut claimed_output: ValTensor<F> = if is_assigned {
+        let input_evals = input.int_evals()?;
+        // returns an integer with the base 2 logarithm
+        tensor::ops::nonlinearities::ilog2(&input_evals.clone(), scale.0 as f64)
+            .par_iter()
+            .map(|x| Value::known(integer_rep_to_felt(*x)))
+            .collect::<Tensor<Value<F>>>()
+            .into()
+    } else {
+        Tensor::new(
+            Some(&vec![Value::<F>::unknown(); input.len()]),
+            &[input.len()],
+        )?
+        .into()
+    };
+    claimed_output.reshape(input.dims())?;
+    region.assign(&config.custom_gates.output, &claimed_output)?;
+    region.increment(claimed_output.len());
+
+    let pow2_of_claimed_output = nonlinearity(
+        config,
+        region,
+        &[claimed_output.clone()],
+        &LookupOp::PowersOfTwo { scale },
+    )?;
+
+    let num_bits = (std::mem::size_of::<IntegerRep>() * 8) as IntegerRep;
+
+    region.update_max_min_lookup_inputs_force(-num_bits, num_bits)?;
+
+    // now subtract 1 from the claimed output
+    let claimed_output_minus_one = pairwise(
+        config,
+        region,
+        &[claimed_output.clone(), unit.clone()],
+        BaseOp::Sub,
+    )?;
+
+    // now add 1 to the claimed output
+    let claimed_output_plus_one = pairwise(
+        config,
+        region,
+        &[claimed_output.clone(), unit.clone()],
+        BaseOp::Add,
+    )?;
+
+    // prior power of 2 is less than claimed output
+    let prior_pow2 = nonlinearity(
+        config,
+        region,
+        &[claimed_output_minus_one],
+        &LookupOp::PowersOfTwo { scale },
+    )?;
+
+    // next power of 2 is greater than claimed output
+    let next_pow2 = nonlinearity(
+        config,
+        region,
+        &[claimed_output_plus_one],
+        &LookupOp::PowersOfTwo { scale },
+    )?;
+
+    // assert that the original input is closest to the claimed output than the prior power of 2 and the next power of 2
+    let distance_to_prior = pairwise(
+        config,
+        region,
+        &[input.clone(), prior_pow2.clone()],
+        BaseOp::Sub,
+    )?;
+
+    // now take abs of the distance
+    let distance_to_prior_l1 = abs(config, region, &[distance_to_prior.clone()])?;
+
+    let distance_to_next = pairwise(
+        config,
+        region,
+        &[input.clone(), next_pow2.clone()],
+        BaseOp::Sub,
+    )?;
+
+    // now take abs of the distance
+    let distance_to_next_l1 = abs(config, region, &[distance_to_next.clone()])?;
+
+    let distance_to_claimed = pairwise(
+        config,
+        region,
+        &[input.clone(), pow2_of_claimed_output.clone()],
+        BaseOp::Sub,
+    )?;
+
+    // now take abs of the distance
+    let distance_to_claimed_l1 = abs(config, region, &[distance_to_claimed.clone()])?;
+
+    // can be less than or equal because we round up
+    let is_distance_to_prior_less = less_equal(
+        config,
+        region,
+        &[distance_to_claimed_l1.clone(), distance_to_prior_l1.clone()],
+    )?;
+
+    // should be striclty less because we round up
+    let is_distance_to_next_less = less(
+        config,
+        region,
+        &[distance_to_claimed_l1, distance_to_next_l1.clone()],
+    )?;
+
+    let is_distance_to_prior_less_and_distance_to_next_less = and(
+        config,
+        region,
+        &[
+            is_distance_to_prior_less.clone(),
+            is_distance_to_next_less.clone(),
+        ],
+    )?;
+
+    let mut comparison_unit = create_constant_tensor(
+        integer_rep_to_felt(1),
+        is_distance_to_prior_less_and_distance_to_next_less.len(),
+    );
+
+    comparison_unit.reshape(is_distance_to_prior_less_and_distance_to_next_less.dims())?;
+
+    // assigned unit
+    let assigned_unit = region.assign(&config.custom_gates.inputs[1], &comparison_unit)?;
+    region.increment(assigned_unit.len());
+
+    // assert that the values are truthy
+    enforce_equality(
+        config,
+        region,
+        &[
+            is_distance_to_prior_less_and_distance_to_next_less,
+            assigned_unit.clone(),
+        ],
+    )?;
+
+    // get a linear interpolation now
+
+    let sign_of_distance_to_claimed = sign(config, region, &[distance_to_claimed.clone()])?;
+    let sign_of_distance_to_claimed_is_positive = equals(
+        config,
+        region,
+        &[sign_of_distance_to_claimed.clone(), assigned_unit.clone()],
+    )?;
+
+    let sign_of_distance_to_claimed_is_negative = not(
+        config,
+        region,
+        &[sign_of_distance_to_claimed_is_positive.clone()],
+    )?;
+
+    let pow2_prior_to_claimed_distance = pairwise(
+        config,
+        region,
+        &[pow2_of_claimed_output.clone(), prior_pow2.clone()],
+        BaseOp::Sub,
+    )?;
+
+    let pow2_next_to_claimed_distance = pairwise(
+        config,
+        region,
+        &[next_pow2.clone(), pow2_of_claimed_output.clone()],
+        BaseOp::Sub,
+    )?;
+
+    let recip_pow2_prior_to_claimed_distance = recip(
+        config,
+        region,
+        &[pow2_prior_to_claimed_distance],
+        scale_as_felt,
+        scale_as_felt * scale_as_felt,
+    )?;
+
+    let interpolated_distance = pairwise(
+        config,
+        region,
+        &[
+            recip_pow2_prior_to_claimed_distance.clone(),
+            distance_to_claimed.clone(),
+        ],
+        BaseOp::Mult,
+    )?;
+
+    let gated_prior_interpolated_distance = pairwise(
+        config,
+        region,
+        &[
+            interpolated_distance.clone(),
+            sign_of_distance_to_claimed_is_negative.clone(),
+        ],
+        BaseOp::Mult,
+    )?;
+
+    let recip_next_to_claimed_distance = recip(
+        config,
+        region,
+        &[pow2_next_to_claimed_distance],
+        scale_as_felt,
+        scale_as_felt * scale_as_felt,
+    )?;
+
+    let interpolated_distance_next = pairwise(
+        config,
+        region,
+        &[
+            recip_next_to_claimed_distance.clone(),
+            distance_to_claimed.clone(),
+        ],
+        BaseOp::Mult,
+    )?;
+
+    let gated_next_interpolated_distance = pairwise(
+        config,
+        region,
+        &[
+            interpolated_distance_next.clone(),
+            sign_of_distance_to_claimed_is_positive.clone(),
+        ],
+        BaseOp::Mult,
+    )?;
+
+    let scaled_claimed_output = pairwise(
+        config,
+        region,
+        &[
+            claimed_output.clone(),
+            assigned_triple_scaled_as_felt_tensor,
+        ],
+        BaseOp::Mult,
+    )?;
+
+    let claimed_output = pairwise(
+        config,
+        region,
+        &[
+            scaled_claimed_output.clone(),
+            gated_prior_interpolated_distance.clone(),
+        ],
+        BaseOp::Add,
+    )?;
+
+    let claimed_output = pairwise(
+        config,
+        region,
+        &[
+            claimed_output.clone(),
+            gated_next_interpolated_distance.clone(),
+        ],
+        BaseOp::Add,
+    )?;
+
+    // now multiply the claimed output by ln2
+    pairwise(config, region, &[claimed_output, ln2_tensor], BaseOp::Mult)
+}
+
+/// round layout
+/// # Arguments
+/// * `config` - BaseConfig
+/// * `region` - RegionCtx
+/// * `values` - &[ValTensor<F>; 1]
+/// * `scale` - utils::F32
+/// * `legs` - usize
+/// # Returns
+/// * ValTensor<F>
+/// # Example
+/// ```
+/// use ezkl::tensor::Tensor;
+/// use ezkl::fieldutils::IntegerRep;
+/// use ezkl::circuit::ops::layouts::round;
+/// use ezkl::tensor::val::ValTensor;
+/// use halo2curves::bn256::Fr as Fp;
+/// use ezkl::circuit::region::RegionCtx;
+/// use ezkl::circuit::region::RegionSettings;
+/// use ezkl::circuit::BaseConfig;
+/// let dummy_config = BaseConfig::dummy(12, 2);
+/// let mut dummy_region = RegionCtx::new_dummy(0,2,RegionSettings::all_true(128,2));
+/// let x = ValTensor::from_integer_rep_tensor(Tensor::<IntegerRep>::new(
+/// Some(&[3, -2, 3, 1]),
+/// &[1, 1, 2, 2],
+/// ).unwrap());
+/// let result = round::<Fp>(&dummy_config, &mut dummy_region, &[x], 4.0.into(), 2).unwrap();
+/// let expected = Tensor::<IntegerRep>::new(Some(&[4, -4, 4, 0]), &[1, 1, 2, 2]).unwrap();
+/// assert_eq!(result.int_evals().unwrap(), expected);
+/// ```
+///
+pub fn round<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
+    config: &BaseConfig<F>,
+    region: &mut RegionCtx<F>,
+    values: &[ValTensor<F>; 1],
+    scale: utils::F32,
+    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)?;
+    // 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);
+
+    let one = create_constant_tensor(integer_rep_to_felt(1), 1);
+    let assigned_one = region.assign(&config.custom_gates.inputs[1], &one)?;
+    let negative_one = create_constant_tensor(integer_rep_to_felt(-1), 1);
+    let assigned_negative_one = region.assign(&config.custom_gates.output, &negative_one)?;
+
+    region.increment(1);
+
+    // if scale is not exactly divisible by 2 we warn
+    if scale.0 % 2.0 != 0.0 {
+        log::warn!("Scale is not exactly divisible by 2.0, rounding may not be accurate");
+    }
+
+    let midway_point: ValTensor<F> = create_constant_tensor(
+        integer_rep_to_felt((scale.0 / 2.0).round() as IntegerRep),
+        1,
+    );
+    let assigned_midway_point = region.assign(&config.custom_gates.inputs[1], &midway_point)?;
+
+    let dims = decomposition.dims().to_vec();
+    let first_dims = decomposition.dims().to_vec()[..decomposition.dims().len() - 1].to_vec();
+
+    let mut incremented_tensor = Tensor::new(None, &first_dims)?;
+
+    let cartesian_coord = first_dims
+        .iter()
+        .map(|x| 0..*x)
+        .multi_cartesian_product()
+        .collect::<Vec<_>>();
+
+    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 = decomposition.get_slice(&slice)?;
+            sliced_input.flatten();
+            let last_elem = sliced_input.last()?;
+
+            let sign = sliced_input.first()?;
+            let is_positive = equals(config, region, &[sign.clone(), assigned_one.clone()])?;
+            let is_negative = equals(config, region, &[sign, assigned_negative_one.clone()])?;
+
+            let is_greater_than_midway = greater_equal(
+                config,
+                region,
+                &[last_elem.clone(), assigned_midway_point.clone()],
+            )?;
+
+            // if greater than midway point and positive, increment
+            let is_positive_and_more_than_midway = and(
+                config,
+                region,
+                &[is_positive.clone(), is_greater_than_midway.clone()],
+            )?;
+
+            // is less than midway point and negative, decrement
+            let is_negative_and_more_than_midway = and(
+                config,
+                region,
+                &[is_negative.clone(), is_greater_than_midway],
+            )?;
+
+            let conditions_for_increment = or(
+                config,
+                region,
+                &[
+                    is_positive_and_more_than_midway.clone(),
+                    is_negative_and_more_than_midway.clone(),
+                ],
+            )?;
+
+            // increment the penultimate element
+            let incremented_elem = pairwise(
+                config,
+                region,
+                &[
+                    sliced_input.get_slice(&[sliced_input.len() - 2..sliced_input.len() - 1])?,
+                    conditions_for_increment.clone(),
+                ],
+                BaseOp::Add,
+            )?;
+
+            let mut inner_tensor = sliced_input.get_inner_tensor()?.clone();
+            inner_tensor[sliced_input.len() - 2] =
+                incremented_elem.get_inner_tensor()?.clone()[0].clone();
+
+            // set the last elem to zero
+            inner_tensor[sliced_input.len() - 1] = zero.clone();
+
+            Ok(inner_tensor.clone())
+        };
+
+    region.apply_in_loop(&mut incremented_tensor, inner_loop_function)?;
+
+    let mut incremented_tensor = incremented_tensor.combine()?;
+    incremented_tensor.reshape(&dims)?;
+
+    recompose(
+        config,
+        region,
+        &[incremented_tensor.into()],
+        &(scale.0 as usize),
+    )
+}
+
+/// round half to even layout
+/// # Arguments
+/// * `config` - BaseConfig
+/// * `region` - RegionCtx
+/// * `values` - &[ValTensor<F>; 1]
+/// * `scale` - utils::F32
+/// * `legs` - usize
+/// # Returns
+/// * ValTensor<F>
+/// # Example
+/// ```
+/// use ezkl::tensor::Tensor;
+/// use ezkl::fieldutils::IntegerRep;
+/// use ezkl::circuit::ops::layouts::round;
+/// use ezkl::tensor::val::ValTensor;
+/// use halo2curves::bn256::Fr as Fp;
+/// use ezkl::circuit::region::RegionCtx;
+/// use ezkl::circuit::region::RegionSettings;
+/// use ezkl::circuit::BaseConfig;
+/// let dummy_config = BaseConfig::dummy(12, 2);
+/// let mut dummy_region = RegionCtx::new_dummy(0,2,RegionSettings::all_true(128,2));
+/// let x = ValTensor::from_integer_rep_tensor(Tensor::<IntegerRep>::new(
+/// Some(&[3, -2, 3, 1]),
+/// &[1, 1, 2, 2],
+/// ).unwrap());
+/// let result = round::<Fp>(&dummy_config, &mut dummy_region, &[x], 4.0.into(), 2).unwrap();
+/// let expected = Tensor::<IntegerRep>::new(Some(&[4, -4, 4, 0]), &[1, 1, 2, 2]).unwrap();
+/// assert_eq!(result.int_evals().unwrap(), expected);
+/// ```
+///
+pub fn round_half_to_even<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
+    config: &BaseConfig<F>,
+    region: &mut RegionCtx<F>,
+    values: &[ValTensor<F>; 1],
+    scale: utils::F32,
+    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)?;
+    // 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);
+
+    // if scale is not exactly divisible by 2 we warn
+    if scale.0 % 2.0 != 0.0 {
+        log::warn!("Scale is not exactly divisible by 2.0, rounding may not be accurate");
+    }
+
+    let midway_point: ValTensor<F> = create_constant_tensor(
+        integer_rep_to_felt((scale.0 / 2.0).round() as IntegerRep),
+        1,
+    );
+    let assigned_midway_point = region.assign(&config.custom_gates.inputs[1], &midway_point)?;
+
+    region.increment(1);
+
+    let dims = decomposition.dims().to_vec();
+    let first_dims = decomposition.dims().to_vec()[..decomposition.dims().len() - 1].to_vec();
+
+    let mut incremented_tensor = Tensor::new(None, &first_dims)?;
+
+    let cartesian_coord = first_dims
+        .iter()
+        .map(|x| 0..*x)
+        .multi_cartesian_product()
+        .collect::<Vec<_>>();
+
+    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 = decomposition.get_slice(&slice)?;
+            sliced_input.flatten();
+            let last_elem = sliced_input.last()?;
+
+            let penultimate_elem =
+                sliced_input.get_slice(&[sliced_input.len() - 2..sliced_input.len() - 1])?;
+
+            let is_equal_to_midway = equals(
+                config,
+                region,
+                &[last_elem.clone(), assigned_midway_point.clone()],
+            )?;
+            // penultimate_elem is equal to midway point and even, do nothing
+            let is_odd = nonlinearity(
+                config,
+                region,
+                &[penultimate_elem.clone()],
+                &LookupOp::IsOdd,
+            )?;
+
+            let is_odd_and_equal_to_midway = and(
+                config,
+                region,
+                &[is_odd.clone(), is_equal_to_midway.clone()],
+            )?;
+
+            let is_greater_than_midway = greater(
+                config,
+                region,
+                &[last_elem.clone(), assigned_midway_point.clone()],
+            )?;
+
+            // if the number is equal to midway point and odd increment, or if it is is_greater_than_midway
+            let is_odd_and_equal_to_midway_or_greater_than_midway = or(
+                config,
+                region,
+                &[
+                    is_odd_and_equal_to_midway.clone(),
+                    is_greater_than_midway.clone(),
+                ],
+            )?;
+
+            // increment the penultimate element
+            let incremented_elem = pairwise(
+                config,
+                region,
+                &[
+                    sliced_input.get_slice(&[sliced_input.len() - 2..sliced_input.len() - 1])?,
+                    is_odd_and_equal_to_midway_or_greater_than_midway.clone(),
+                ],
+                BaseOp::Add,
+            )?;
+
+            let mut inner_tensor = sliced_input.get_inner_tensor()?.clone();
+            inner_tensor[sliced_input.len() - 2] =
+                incremented_elem.get_inner_tensor()?.clone()[0].clone();
+
+            // set the last elem to zero
+            inner_tensor[sliced_input.len() - 1] = zero.clone();
+
+            Ok(inner_tensor.clone())
+        };
+
+    region.update_max_min_lookup_inputs_force(0, scale.0 as IntegerRep)?;
+
+    region.apply_in_loop(&mut incremented_tensor, inner_loop_function)?;
+
+    let mut incremented_tensor = incremented_tensor.combine()?;
+    incremented_tensor.reshape(&dims)?;
+
+    recompose(
+        config,
+        region,
+        &[incremented_tensor.into()],
+        &(scale.0 as usize),
+    )
+}
+
+pub(crate) fn recompose<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
+    config: &BaseConfig<F>,
+    region: &mut RegionCtx<F>,
+    values: &[ValTensor<F>; 1],
+    base: &usize,
+) -> Result<ValTensor<F>, CircuitError> {
+    let input = values[0].clone();
+
+    let first_dims = input.dims().to_vec()[..input.dims().len() - 1].to_vec();
+    let n = input.dims().last().unwrap() - 1;
+
+    let is_assigned = !input.all_prev_assigned();
+
+    let bases: ValTensor<F> = Tensor::from(
+        (0..n)
+            .rev()
+            .map(|x| ValType::Constant(integer_rep_to_felt(base.pow(x as u32) as IntegerRep))),
+    )
+    .into();
+
+    // multiply and sum the values
+    let mut output: Tensor<Tensor<ValType<F>>> = Tensor::new(None, &first_dims)?;
+
+    let cartesian_coord = first_dims
+        .iter()
+        .map(|x| 0..*x)
+        .multi_cartesian_product()
+        .collect::<Vec<_>>();
+
+    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();
+
+            if !is_assigned {
+                sliced_input = region.assign(&config.custom_gates.inputs[0], &sliced_input)?;
+            }
+
+            // 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()])?;
+
+            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())
+}
+
 pub(crate) fn decompose<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
     config: &BaseConfig<F>,
     region: &mut RegionCtx<F>,

src/circuit/ops/lookup.rs

@@ -4,7 +4,6 @@ use serde::{Deserialize, Serialize};
 use crate::{
     circuit::{layouts, table::Range, utils},
     fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep},
-    graph::multiplier_to_scale,
     tensor::{self, Tensor, TensorError, TensorType},
 };
 
@@ -16,15 +15,12 @@ use halo2curves::ff::PrimeField;
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Deserialize, Serialize)]
 pub enum LookupOp {
     Div { denom: utils::F32 },
-    Cast { scale: utils::F32 },
-    Ceil { scale: utils::F32 },
-    Floor { scale: utils::F32 },
-    Round { scale: utils::F32 },
-    RoundHalfToEven { scale: utils::F32 },
+    IsOdd,
+    PowersOfTwo { scale: utils::F32 },
+    Ln { scale: utils::F32 },
     Sqrt { scale: utils::F32 },
     Rsqrt { scale: utils::F32 },
     Sigmoid { scale: utils::F32 },
-    Ln { scale: utils::F32 },
     Exp { scale: utils::F32 },
     Cos { scale: utils::F32 },
     ACos { scale: utils::F32 },
@@ -54,19 +50,16 @@ impl LookupOp {
     /// as path
     pub fn as_path(&self) -> String {
         match self {
-            LookupOp::Ceil { scale } => format!("ceil_{}", scale),
-            LookupOp::Floor { scale } => format!("floor_{}", scale),
-            LookupOp::Round { scale } => format!("round_{}", scale),
-            LookupOp::RoundHalfToEven { scale } => format!("round_half_to_even_{}", scale),
             LookupOp::Pow { scale, a } => format!("pow_{}_{}", scale, a),
+            LookupOp::Ln { scale } => format!("ln_{}", scale),
+            LookupOp::PowersOfTwo { scale } => format!("pow2_{}", scale),
+            LookupOp::IsOdd => "is_odd".to_string(),
             LookupOp::Div { denom } => format!("div_{}", denom),
-            LookupOp::Cast { scale } => format!("cast_{}", scale),
             LookupOp::Sigmoid { scale } => format!("sigmoid_{}", scale),
             LookupOp::Sqrt { scale } => format!("sqrt_{}", scale),
             LookupOp::Rsqrt { scale } => format!("rsqrt_{}", scale),
             LookupOp::Erf { scale } => format!("erf_{}", scale),
             LookupOp::Exp { scale } => format!("exp_{}", scale),
-            LookupOp::Ln { scale } => format!("ln_{}", scale),
             LookupOp::Cos { scale } => format!("cos_{}", scale),
             LookupOp::ACos { scale } => format!("acos_{}", scale),
             LookupOp::Cosh { scale } => format!("cosh_{}", scale),
@@ -91,27 +84,19 @@ impl LookupOp {
         let x = x[0].clone().map(|x| felt_to_integer_rep(x));
         let res =
             match &self {
-                LookupOp::Ceil { scale } => {
-                    Ok::<_, TensorError>(tensor::ops::nonlinearities::ceil(&x, scale.into()))
+                LookupOp::Ln { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::ln(&x, scale.into()))
                 }
-                LookupOp::Floor { scale } => {
-                    Ok::<_, TensorError>(tensor::ops::nonlinearities::floor(&x, scale.into()))
+                LookupOp::PowersOfTwo { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::ipow2(&x, scale.0.into()))
                 }
-                LookupOp::Round { scale } => {
-                    Ok::<_, TensorError>(tensor::ops::nonlinearities::round(&x, scale.into()))
-                }
-                LookupOp::RoundHalfToEven { scale } => Ok::<_, TensorError>(
-                    tensor::ops::nonlinearities::round_half_to_even(&x, scale.into()),
-                ),
+                LookupOp::IsOdd => Ok::<_, TensorError>(tensor::ops::nonlinearities::is_odd(&x)),
                 LookupOp::Pow { scale, a } => Ok::<_, TensorError>(
                     tensor::ops::nonlinearities::pow(&x, scale.0.into(), a.0.into()),
                 ),
                 LookupOp::Div { denom } => Ok::<_, TensorError>(
                     tensor::ops::nonlinearities::const_div(&x, f32::from(*denom).into()),
                 ),
-                LookupOp::Cast { scale } => Ok::<_, TensorError>(
-                    tensor::ops::nonlinearities::const_div(&x, f32::from(*scale).into()),
-                ),
                 LookupOp::Sigmoid { scale } => {
                     Ok::<_, TensorError>(tensor::ops::nonlinearities::sigmoid(&x, scale.into()))
                 }
@@ -127,9 +112,6 @@ impl LookupOp {
                 LookupOp::Exp { scale } => {
                     Ok::<_, TensorError>(tensor::ops::nonlinearities::exp(&x, scale.into()))
                 }
-                LookupOp::Ln { scale } => {
-                    Ok::<_, TensorError>(tensor::ops::nonlinearities::ln(&x, scale.into()))
-                }
                 LookupOp::Cos { scale } => {
                     Ok::<_, TensorError>(tensor::ops::nonlinearities::cos(&x, scale.into()))
                 }
@@ -186,14 +168,11 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Lookup
     /// Returns the name of the operation
     fn as_string(&self) -> String {
         match self {
-            LookupOp::Ceil { scale } => format!("CEIL(scale={})", scale),
-            LookupOp::Floor { scale } => format!("FLOOR(scale={})", scale),
-            LookupOp::Round { scale } => format!("ROUND(scale={})", scale),
-            LookupOp::RoundHalfToEven { scale } => format!("ROUND_HALF_TO_EVEN(scale={})", scale),
+            LookupOp::Ln { scale } => format!("LN(scale={})", scale),
+            LookupOp::PowersOfTwo { scale } => format!("POWERS_OF_TWO(scale={})", scale),
+            LookupOp::IsOdd => "IS_ODD".to_string(),
             LookupOp::Pow { a, scale } => format!("POW(scale={}, exponent={})", scale, a),
             LookupOp::Div { denom, .. } => format!("DIV(denom={})", denom),
-            LookupOp::Cast { scale } => format!("CAST(scale={})", scale),
-            LookupOp::Ln { scale } => format!("LN(scale={})", scale),
             LookupOp::Sigmoid { scale } => format!("SIGMOID(scale={})", scale),
             LookupOp::Sqrt { scale } => format!("SQRT(scale={})", scale),
             LookupOp::Erf { scale } => format!("ERF(scale={})", scale),
@@ -232,10 +211,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Lookup
     /// Returns the scale of the output of the operation.
     fn out_scale(&self, inputs_scale: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
         let scale = match self {
-            LookupOp::Cast { scale } => {
-                let in_scale = inputs_scale[0];
-                in_scale + multiplier_to_scale(1. / scale.0 as f64)
-            }
             _ => inputs_scale[0],
         };
         Ok(scale)

src/circuit/ops/region.rs

@@ -474,6 +474,17 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         Ok(())
     }
 
+    /// Update the max and min forcefully 
+    pub fn update_max_min_lookup_inputs_force(
+        &mut self,
+        min: IntegerRep,
+        max: IntegerRep,
+    ) -> Result<(), CircuitError> {
+        self.statistics.max_lookup_inputs = self.statistics.max_lookup_inputs.max(max);
+        self.statistics.min_lookup_inputs = self.statistics.min_lookup_inputs.min(min);
+        Ok(())
+    }
+
     /// Update the max and min from inputs
     pub fn update_max_min_lookup_range(&mut self, range: Range) -> Result<(), CircuitError> {
         if range.0 > range.1 {

src/circuit/table.rs

@@ -150,12 +150,16 @@ pub fn num_cols_required(range_len: IntegerRep, col_size: usize) -> usize {
 }
 
 impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
+    /// get largest element represented by the range
+    pub fn largest(&self) -> IntegerRep {
+        self.range.0 + (self.col_size * self.table_inputs.len() - 1) as IntegerRep
+    }
     fn name(&self) -> String {
         format!(
             "{}_{}_{}",
             self.nonlinearity.as_path(),
             self.range.0,
-            self.range.1
+            self.largest()
         )
     }
     /// Configures the table.
@@ -222,7 +226,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
         }
 
         let smallest = self.range.0;
-        let largest = self.range.1;
+        let largest = self.largest();
 
         let gen_table = || -> Result<(Tensor<F>, Tensor<F>), crate::tensor::TensorError> {
             let inputs = Tensor::from(smallest..=largest)
@@ -291,6 +295,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
 
                                 row_offset += chunk_idx * self.col_size;
                                 let (x, y) = self.cartesian_coord(row_offset);
+
                                 if !preassigned_input {
                                     table.assign_cell(
                                         || format!("nl_i_col row {}", row_offset),

src/commands.rs

@@ -333,18 +333,6 @@ impl<'source> FromPyObject<'source> for ContractType {
         }
     }
 }
-// not wasm
-use lazy_static::lazy_static;
-
-// if CARGO VERSION is 0.0.0 replace with "source - no compatibility guaranteed"
-lazy_static! {
-    /// The version of the ezkl library
-    pub static ref VERSION: &'static str =  if env!("CARGO_PKG_VERSION") == "0.0.0" {
-       "source - no compatibility guaranteed"
-    } else {
-        env!("CARGO_PKG_VERSION")
-    };
-}
 
 /// Get the styles for the CLI
 pub fn get_styles() -> clap::builder::Styles {
@@ -395,7 +383,7 @@ pub fn print_completions<G: Generator>(gen: G, cmd: &mut Command) {
 #[allow(missing_docs)]
 #[derive(Parser, Debug, Clone)]
 #[command(author, about, long_about = None)]
-#[clap(version = *VERSION, styles = get_styles(), trailing_var_arg = true)]
+#[clap(version = crate::version(), styles = get_styles(), trailing_var_arg = true)]
 pub struct Cli {
     /// If provided, outputs the completion file for given shell
     #[clap(long = "generate", value_parser)]
@@ -508,7 +496,7 @@ pub enum Commands {
         /// Gets an SRS from a circuit settings file.
     #[command(name = "get-srs")]
     GetSrs {
-        /// The path to output the desired srs file, if set to None will save to $EZKL_REPO_PATH/srs
+        /// The path to output the desired srs file, if set to None will save to ~/.ezkl/srs
         #[arg(long, default_value = None, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// Path to the circuit settings .json file to read in logrows from. Overriden by logrows if specified.
@@ -555,7 +543,7 @@ pub enum Commands {
         /// The path to save the proving key to
         #[arg(long, default_value = DEFAULT_PK_AGGREGATED, value_hint = clap::ValueHint::FilePath)]
         pk_path: Option<PathBuf>,
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// logrows used for aggregation circuit
@@ -582,7 +570,7 @@ pub enum Commands {
         /// The path to output the proof file to
         #[arg(long, default_value = DEFAULT_PROOF_AGGREGATED, value_hint = clap::ValueHint::FilePath)]
         proof_path: Option<PathBuf>,
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
         #[arg(
@@ -624,7 +612,7 @@ pub enum Commands {
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT, value_hint = clap::ValueHint::FilePath)]
         compiled_circuit: Option<PathBuf>,
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// The path to output the verification key file to
@@ -701,7 +689,7 @@ pub enum Commands {
         /// The path to output the proof file to
         #[arg(long, default_value = DEFAULT_PROOF, value_hint = clap::ValueHint::FilePath)]
         proof_path: Option<PathBuf>,
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         #[arg(
@@ -733,7 +721,7 @@ pub enum Commands {
         /// Creates an Evm verifier for a single proof
     #[command(name = "create-evm-verifier")]
     CreateEvmVerifier {
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
@@ -755,7 +743,7 @@ pub enum Commands {
         /// Creates an Evm verifier artifact for a single proof to be used by the reusable verifier
     #[command(name = "create-evm-vka")]
     CreateEvmVKArtifact {
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
@@ -798,7 +786,7 @@ pub enum Commands {
         /// Creates an Evm verifier for an aggregate proof
     #[command(name = "create-evm-verifier-aggr")]
     CreateEvmVerifierAggr {
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// The path to load the desired verification key file
@@ -831,7 +819,7 @@ pub enum Commands {
         /// The path to the verification key file (generated using the setup command)
         #[arg(long, default_value = DEFAULT_VK, value_hint = clap::ValueHint::FilePath)]
         vk_path: Option<PathBuf>,
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// Reduce SRS logrows to the number of instances rather than the number of logrows used for proofs (only works if the srs were generated in the same ceremony)
@@ -849,7 +837,7 @@ pub enum Commands {
         /// reduced srs
         #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION, action = clap::ArgAction::SetTrue)]
         reduced_srs: Option<bool>,
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// logrows used for aggregation circuit

src/execute.rs

@@ -677,11 +677,12 @@ pub(crate) async fn get_srs_cmd(
                 pb.finish_with_message("SRS validated.");
 
             info!("Saving SRS to disk...");
-            let mut file = std::fs::File::create(get_srs_path(k, srs_path.clone(), commitment))?;
+            let computed_srs_path = get_srs_path(k, srs_path.clone(), commitment);
+            let mut file = std::fs::File::create(&computed_srs_path)?;
             let mut buffer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, &mut file);
             params.write(&mut buffer)?;
 
-            info!("Saved SRS to disk.");
+            info!("Saved SRS to {}.", computed_srs_path.as_os_str().to_str().unwrap_or("disk"));
 
             info!("SRS downloaded");
         } else {

src/graph/mod.rs

@@ -133,6 +133,8 @@ pub struct GraphWitness {
     pub min_lookup_inputs: IntegerRep,
     /// max range check size
     pub max_range_size: IntegerRep,
+    /// (optional) version of ezkl used
+    pub version: Option<String>,
 }
 
 impl GraphWitness {
@@ -161,6 +163,7 @@ impl GraphWitness {
             max_lookup_inputs: 0,
             min_lookup_inputs: 0,
             max_range_size: 0,
+            version: None,
         }
     }
 
@@ -1350,6 +1353,7 @@ impl GraphCircuit {
             max_lookup_inputs: model_results.max_lookup_inputs,
             min_lookup_inputs: model_results.min_lookup_inputs,
             max_range_size: model_results.max_range_size,
+            version: Some(crate::version().to_string()),
         };
 
         witness.generate_rescaled_elements(

src/graph/utilities.rs

@@ -803,7 +803,7 @@ pub fn new_op_from_onnx(
             }
         }
         "Recip" => {
-            let in_scale = inputs[0].out_scales()[0];
+            let in_scale = input_scales[0];
             let max_scale = std::cmp::max(scales.get_max(), in_scale);
             // If the input scale is larger than the params scale
             SupportedOp::Hybrid(HybridOp::Recip {
@@ -837,61 +837,70 @@ pub fn new_op_from_onnx(
         "Abs" => SupportedOp::Linear(PolyOp::Abs),
         "Neg" => SupportedOp::Linear(PolyOp::Neg),
         "HardSwish" => SupportedOp::Nonlinear(LookupOp::HardSwish {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Sigmoid" => SupportedOp::Nonlinear(LookupOp::Sigmoid {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Sqrt" => SupportedOp::Nonlinear(LookupOp::Sqrt {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Rsqrt" => SupportedOp::Nonlinear(LookupOp::Rsqrt {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Exp" => SupportedOp::Nonlinear(LookupOp::Exp {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
-        }),
-        "Ln" => SupportedOp::Nonlinear(LookupOp::Ln {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
+        "Ln" => {
+            if run_args.bounded_log_lookup {
+                SupportedOp::Hybrid(HybridOp::Ln {
+                    scale: scale_to_multiplier(input_scales[0]).into(),
+                })
+            } else {
+                SupportedOp::Nonlinear(LookupOp::Ln {
+                    scale: scale_to_multiplier(input_scales[0]).into(),
+                })
+            }
+        }
+
         "Sin" => SupportedOp::Nonlinear(LookupOp::Sin {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Cos" => SupportedOp::Nonlinear(LookupOp::Cos {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Tan" => SupportedOp::Nonlinear(LookupOp::Tan {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Asin" => SupportedOp::Nonlinear(LookupOp::ASin {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Acos" => SupportedOp::Nonlinear(LookupOp::ACos {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Atan" => SupportedOp::Nonlinear(LookupOp::ATan {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Sinh" => SupportedOp::Nonlinear(LookupOp::Sinh {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Cosh" => SupportedOp::Nonlinear(LookupOp::Cosh {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Tanh" => SupportedOp::Nonlinear(LookupOp::Tanh {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Asinh" => SupportedOp::Nonlinear(LookupOp::ASinh {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Acosh" => SupportedOp::Nonlinear(LookupOp::ACosh {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Atanh" => SupportedOp::Nonlinear(LookupOp::ATanh {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Erf" => SupportedOp::Nonlinear(LookupOp::Erf {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Source" => {
             let dt = node.outputs[0].fact.datum_type;
@@ -935,11 +944,9 @@ pub fn new_op_from_onnx(
                         replace_const(
                             0,
                             0,
-                            SupportedOp::Nonlinear(LookupOp::Cast {
-                                scale: crate::circuit::utils::F32(scale_to_multiplier(
-                                    input_scales[0],
-                                )
-                                    as f32),
+                            SupportedOp::Hybrid(HybridOp::Floor {
+                                scale: scale_to_multiplier(input_scales[0]).into(),
+                                legs: run_args.decomp_legs,
                             }),
                         )?
                     } else {
@@ -1045,7 +1052,7 @@ pub fn new_op_from_onnx(
                 }
             };
 
-            let in_scale = inputs[0].out_scales()[0];
+            let in_scale = input_scales[0];
             let max_scale = std::cmp::max(scales.get_max(), in_scale);
 
             SupportedOp::Hybrid(HybridOp::Softmax {
@@ -1083,17 +1090,21 @@ pub fn new_op_from_onnx(
                 pool_dims: kernel_shape.to_vec(),
             })
         }
-        "Ceil" => SupportedOp::Nonlinear(LookupOp::Ceil {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+        "Ceil" => SupportedOp::Hybrid(HybridOp::Ceil {
+            scale: scale_to_multiplier(input_scales[0]).into(),
+            legs: run_args.decomp_legs,
         }),
-        "Floor" => SupportedOp::Nonlinear(LookupOp::Floor {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+        "Floor" => SupportedOp::Hybrid(HybridOp::Floor {
+            scale: scale_to_multiplier(input_scales[0]).into(),
+            legs: run_args.decomp_legs,
         }),
-        "Round" => SupportedOp::Nonlinear(LookupOp::Round {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+        "Round" => SupportedOp::Hybrid(HybridOp::Round {
+            scale: scale_to_multiplier(input_scales[0]).into(),
+            legs: run_args.decomp_legs,
         }),
-        "RoundHalfToEven" => SupportedOp::Nonlinear(LookupOp::RoundHalfToEven {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+        "RoundHalfToEven" => SupportedOp::Hybrid(HybridOp::RoundHalfToEven {
+            scale: scale_to_multiplier(input_scales[0]).into(),
+            legs: run_args.decomp_legs,
         }),
         "Sign" => SupportedOp::Linear(PolyOp::Sign),
         "Pow" => {
@@ -1113,7 +1124,7 @@ pub fn new_op_from_onnx(
                     SupportedOp::Linear(PolyOp::Pow(exponent as u32))
                 } else {
                     SupportedOp::Nonlinear(LookupOp::Pow {
-                        scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+                        scale: scale_to_multiplier(input_scales[0]).into(),
                         a: crate::circuit::utils::F32(exponent),
                     })
                 }

src/lib.rs

@@ -108,6 +108,18 @@ use serde::{Deserialize, Serialize};
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tosubcommand::ToFlags;
 
+// if CARGO VERSION is 0.0.0 replace with "source - no compatibility guaranteed"
+/// The version of the ezkl library
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// Get the version of the library
+pub fn version() -> &'static str {
+    match VERSION {
+        "0.0.0" => "source - no compatibility guaranteed",
+        _ => VERSION,
+    }
+}
+
 /// Bindings managment
 #[cfg(any(
     feature = "ios-bindings",
@@ -317,11 +329,18 @@ pub struct RunArgs {
     #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(long, default_value = "2", value_hint = clap::ValueHint::Other))]
     /// the number of legs used for decompositions
     pub decomp_legs: usize,
+    #[cfg_attr(
+        all(feature = "ezkl", not(target_arch = "wasm32")),
+        arg(long, default_value = "false")
+    )]
+    /// use unbounded lookup for the log
+    pub bounded_log_lookup: bool,
 }
 
 impl Default for RunArgs {
     fn default() -> Self {
         Self {
+            bounded_log_lookup: false,
             tolerance: Tolerance::default(),
             input_scale: 7,
             param_scale: 7,

src/pfsys/mod.rs

@@ -59,10 +59,7 @@ fn serde_format_from_str(s: &str) -> halo2_proofs::SerdeFormat {
 
 #[allow(missing_docs)]
 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Deserialize, Serialize, PartialOrd)]
-#[cfg_attr(
-    all(feature = "ezkl", not(target_arch = "wasm32")),
-    derive(ValueEnum)
-)]
+#[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), derive(ValueEnum))]
 pub enum ProofType {
     #[default]
     Single,
@@ -134,10 +131,7 @@ impl<'source> pyo3::FromPyObject<'source> for ProofType {
 
 #[allow(missing_docs)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
-#[cfg_attr(
-    all(feature = "ezkl", not(target_arch = "wasm32")),
-    derive(ValueEnum)
-)]
+#[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), derive(ValueEnum))]
 pub enum StrategyType {
     Single,
     Accum,
@@ -203,10 +197,7 @@ pub enum PfSysError {
 
 #[allow(missing_docs)]
 #[derive(Default, Copy, Clone, Debug, PartialEq, Eq, Deserialize, Serialize, PartialOrd)]
-#[cfg_attr(
-    all(feature = "ezkl", not(target_arch = "wasm32")),
-    derive(ValueEnum)
-)]
+#[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), derive(ValueEnum))]
 pub enum TranscriptType {
     Poseidon,
     #[default]
@@ -324,6 +315,8 @@ where
     pub timestamp: Option<u128>,
     /// commitment
     pub commitment: Option<Commitments>,
+    /// (optional) version of ezkl used to generate the proof
+    version: Option<String>,
 }
 
 #[cfg(feature = "python-bindings")]
@@ -385,6 +378,7 @@ where
                     .as_millis(),
             ),
             commitment,
+            version: Some(crate::version().to_string()),
         }
     }
 
@@ -920,6 +914,7 @@ mod tests {
             pretty_public_inputs: None,
             timestamp: None,
             commitment: None,
+            version: None,
         };
 
         snark

src/tensor/ops.rs

@@ -27,7 +27,7 @@ pub fn get_rep(
     n: usize,
 ) -> Result<Vec<IntegerRep>, DecompositionError> {
     // check if x is too large
-    if x.abs() > (base.pow(n as u32) as IntegerRep) {
+    if x.abs() > (base.pow(n as u32) as IntegerRep) - 1 {
         return Err(DecompositionError::TooLarge(*x, base, n));
     }
     let mut rep = vec![0; n + 1];
@@ -1421,85 +1421,6 @@ pub fn slice<T: TensorType + Send + Sync>(
 pub mod nonlinearities {
     use super::*;
 
-    /// Ceiling operator.
-    /// # Arguments
-    /// * `a` - Tensor
-    /// * `scale` - Single value
-    /// # Examples
-    /// ```
-    /// use ezkl::tensor::Tensor;
-    /// use ezkl::fieldutils::IntegerRep;
-    ///
-    /// use ezkl::tensor::ops::nonlinearities::ceil;
-    /// let x = Tensor::<IntegerRep>::new(
-    ///    Some(&[1, 2, 3, 4, 5, 6]),
-    ///  &[3, 2],
-    /// ).unwrap();
-    /// let result = ceil(&x, 2.0);
-    /// let expected = Tensor::<IntegerRep>::new(Some(&[2, 2, 4, 4, 6, 6]), &[3, 2]).unwrap();
-    /// assert_eq!(result, expected);
-    /// ```
-    pub fn ceil(a: &Tensor<IntegerRep>, scale: f64) -> Tensor<IntegerRep> {
-        a.par_enum_map(|_, a_i| {
-            let kix = (a_i as f64) / scale;
-            let rounded = kix.ceil() * scale;
-            Ok::<_, TensorError>(rounded as IntegerRep)
-        })
-        .unwrap()
-    }
-
-    /// Floor operator.
-    /// # Arguments
-    /// * `a` - Tensor
-    /// * `scale` - Single value
-    /// # Examples
-    /// ```
-    /// use ezkl::tensor::Tensor;
-    /// use ezkl::fieldutils::IntegerRep;
-    /// use ezkl::tensor::ops::nonlinearities::floor;
-    /// let x = Tensor::<IntegerRep>::new(
-    ///   Some(&[1, 2, 3, 4, 5, 6]),
-    ///  &[3, 2],
-    /// ).unwrap();
-    /// let result = floor(&x, 2.0);
-    /// let expected = Tensor::<IntegerRep>::new(Some(&[0, 2, 2, 4, 4, 6]), &[3, 2]).unwrap();
-    /// assert_eq!(result, expected);
-    /// ```
-    pub fn floor(a: &Tensor<IntegerRep>, scale: f64) -> Tensor<IntegerRep> {
-        a.par_enum_map(|_, a_i| {
-            let kix = (a_i as f64) / scale;
-            let rounded = kix.floor() * scale;
-            Ok::<_, TensorError>(rounded as IntegerRep)
-        })
-        .unwrap()
-    }
-
-    /// Round operator.
-    /// # Arguments
-    /// * `a` - Tensor
-    /// * `scale` - Single value
-    /// # Examples
-    /// ```
-    /// use ezkl::tensor::Tensor;
-    /// use ezkl::fieldutils::IntegerRep;
-    /// use ezkl::tensor::ops::nonlinearities::round;
-    /// let x = Tensor::<IntegerRep>::new(
-    ///   Some(&[1, 2, 3, 4, 5, 6]),
-    /// &[3, 2],
-    /// ).unwrap();
-    /// let result = round(&x, 2.0);
-    /// let expected = Tensor::<IntegerRep>::new(Some(&[2, 2, 4, 4, 6, 6]), &[3, 2]).unwrap();
-    /// assert_eq!(result, expected);
-    /// ```
-    pub fn round(a: &Tensor<IntegerRep>, scale: f64) -> Tensor<IntegerRep> {
-        a.par_enum_map(|_, a_i| {
-            let kix = (a_i as f64) / scale;
-            let rounded = kix.round() * scale;
-            Ok::<_, TensorError>(rounded as IntegerRep)
-        })
-        .unwrap()
-    }
-
     /// Round half to even operator.
     /// # Arguments
     /// * `a` - Tensor
@@ -1553,6 +1474,85 @@ pub mod nonlinearities {
         .unwrap()
     }
 
+    /// Checks if a tensor's elements are odd
+    /// # Arguments
+    /// * `a` - Tensor
+    /// * `scale` - Single value
+    /// # Examples
+    /// ```
+    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
+    /// use ezkl::tensor::ops::nonlinearities::is_odd;
+    /// let x = Tensor::<IntegerRep>::new(
+    ///   Some(&[2, 15, 2, 1, 1, 0]),
+    /// &[2, 3],
+    /// ).unwrap();
+    ///
+    /// let result = is_odd(&x);
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[0, 1, 0, 1, 1, 0]), &[2, 3]).unwrap();
+    /// assert_eq!(result, expected);
+    /// ```
+    pub fn is_odd(a: &Tensor<IntegerRep>) -> Tensor<IntegerRep> {
+        a.par_enum_map(|_, a_i| {
+            let rounded = if a_i % 2 == 0 { 0 } else { 1 };
+            Ok::<_, TensorError>(rounded)
+        })
+        .unwrap()
+    }
+
+    /// Powers of 2
+    /// # Arguments
+    /// * `a` - Tensor
+    /// * `scale` - Single value
+    /// # Examples
+    /// ```
+    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
+    /// use ezkl::tensor::ops::nonlinearities::ipow2;
+    /// let x = Tensor::<IntegerRep>::new(
+    ///  Some(&[2, 15, 2, 1, 1, 0]),
+    /// &[2, 3],
+    /// ).unwrap();
+    /// let result = ipow2(&x, 1.0);
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[4, 32768, 4, 2, 2, 1]), &[2, 3]).unwrap();
+    /// assert_eq!(result, expected);
+    /// ```
+    pub fn ipow2(a: &Tensor<IntegerRep>, scale_output: f64) -> Tensor<IntegerRep> {
+        a.par_enum_map(|_, a_i| {
+            let kix = a_i as f64;
+            let kix = scale_output * (2.0_f64).powf(kix);
+            let rounded = kix.round();
+            Ok::<_, TensorError>(rounded as IntegerRep)
+        })
+        .unwrap()
+    }
+
+    /// Elementwise applies ln base 2 to a tensor of integers.
+    /// # Arguments
+    /// * `a` - Tensor
+    /// * `scale_input` - Single value
+    /// ```
+    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
+    /// use ezkl::tensor::ops::nonlinearities::ilog2;
+    /// let x = Tensor::<IntegerRep>::new(
+    ///    Some(&[2, 15, 2, 1, 1, 2]),
+    /// &[2, 3],
+    /// ).unwrap();
+    /// let result = ilog2(&x, 1.0);
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 4, 1, 0, 0, 1]), &[2, 3]).unwrap();
+    /// assert_eq!(result, expected);
+    /// ```
+    pub fn ilog2(a: &Tensor<IntegerRep>, scale_input: f64) -> Tensor<IntegerRep> {
+        a.par_enum_map(|_, a_i| {
+            let kix = (a_i as f64) / scale_input;
+            let kix = (kix).log2();
+            let rounded = kix.round();
+            Ok::<_, TensorError>(rounded as IntegerRep)
+        })
+        .unwrap()
+    }
+
     /// Elementwise applies sigmoid to a tensor of integers.
     /// # Arguments
     ///
@@ -1681,12 +1681,11 @@ pub mod nonlinearities {
         .unwrap()
     }
 
-    /// Elementwise applies exponential to a tensor of integers.
+    /// Elementwise applies ln to a tensor of integers.
     /// # Arguments
     ///
     /// * `a` - Tensor
     /// * `scale_input` - Single value
-    /// * `scale_output` - Single value
     /// # Examples
     /// ```
     /// use ezkl::tensor::Tensor;
@@ -1721,27 +1720,6 @@ pub mod nonlinearities {
         .unwrap()
     }
 
-    /// Elementwise applies sign to a tensor of integers.
-    /// # Arguments
-    /// * `a` - Tensor
-    /// # Examples
-    /// ```
-    /// use ezkl::tensor::Tensor;
-    /// use ezkl::fieldutils::IntegerRep;
-    /// use ezkl::tensor::ops::nonlinearities::sign;
-    /// let x = Tensor::<IntegerRep>::new(
-    ///    Some(&[-2, 15, 2, 1, 1, 0]),
-    ///  &[2, 3],
-    /// ).unwrap();
-    /// let result = sign(&x);
-    /// let expected = Tensor::<IntegerRep>::new(Some(&[-1, 1, 1, 1, 1, 0]), &[2, 3]).unwrap();
-    /// assert_eq!(result, expected);
-    /// ```
-    pub fn sign(a: &Tensor<IntegerRep>) -> Tensor<IntegerRep> {
-        a.par_enum_map(|_, a_i| Ok::<_, TensorError>(a_i.signum()))
-            .unwrap()
-    }
-
     /// Elementwise applies square root to a tensor of integers.
     /// # Arguments
     ///
@@ -2225,101 +2203,6 @@ pub mod nonlinearities {
         .unwrap()
     }
 
-    /// Elementwise applies leaky relu to a tensor of integers.
-    /// # Arguments
-    ///
-    /// * `a` - Tensor
-    /// * `scale` - Single value
-    /// * `slope` - Single value
-    /// # Examples
-    /// ```
-    /// use ezkl::tensor::Tensor;
-    /// use ezkl::fieldutils::IntegerRep;
-    /// use ezkl::tensor::ops::nonlinearities::leakyrelu;
-    /// let x = Tensor::<IntegerRep>::new(
-    ///     Some(&[2, 15, 2, 1, 1, -5]),
-    ///     &[2, 3],
-    /// ).unwrap();
-    /// let result = leakyrelu(&x, 0.1);
-    /// let expected = Tensor::<IntegerRep>::new(Some(&[2, 15, 2, 1, 1, -1]), &[2, 3]).unwrap();
-    /// assert_eq!(result, expected);
-    /// ```
-    pub fn leakyrelu(a: &Tensor<IntegerRep>, slope: f64) -> Tensor<IntegerRep> {
-        a.par_enum_map(|_, a_i| {
-            let rounded = if a_i < 0 {
-                let d_inv_x = (slope) * (a_i as f64);
-                d_inv_x.round() as IntegerRep
-            } else {
-                let d_inv_x = a_i as f64;
-                d_inv_x.round() as IntegerRep
-            };
-            Ok::<_, TensorError>(rounded)
-        })
-        .unwrap()
-    }
-
-    /// Elementwise applies max to a tensor of integers.
-    /// # Arguments
-    /// * `a` - Tensor
-    /// * `b` - scalar
-    /// # Examples
-    /// ```
-    /// use ezkl::tensor::Tensor;
-    /// use ezkl::fieldutils::IntegerRep;
-    /// use ezkl::tensor::ops::nonlinearities::max;
-    /// let x = Tensor::<IntegerRep>::new(
-    ///    Some(&[2, 15, 2, 1, 1, -5]),
-    ///   &[2, 3],
-    /// ).unwrap();
-    /// let result = max(&x, 1.0, 1.0);
-    /// let expected = Tensor::<IntegerRep>::new(Some(&[2, 15, 2, 1, 1, 1]), &[2, 3]).unwrap();
-    /// assert_eq!(result, expected);
-    /// ```
-    pub fn max(a: &Tensor<IntegerRep>, scale_input: f64, threshold: f64) -> Tensor<IntegerRep> {
-        // calculate value of output
-        a.par_enum_map(|_, a_i| {
-            let d_inv_x = (a_i as f64) / scale_input;
-            let rounded = if d_inv_x <= threshold {
-                (threshold * scale_input).round() as IntegerRep
-            } else {
-                (d_inv_x * scale_input).round() as IntegerRep
-            };
-            Ok::<_, TensorError>(rounded)
-        })
-        .unwrap()
-    }
-
-    /// Elementwise applies min to a tensor of integers.
-    /// # Arguments
-    /// * `a` - Tensor
-    /// * `b` - scalar
-    /// # Examples
-    /// ```
-    /// use ezkl::tensor::Tensor;
-    /// use ezkl::fieldutils::IntegerRep;
-    /// use ezkl::tensor::ops::nonlinearities::min;
-    /// let x = Tensor::<IntegerRep>::new(
-    ///    Some(&[2, 15, 2, 1, 1, -5]),
-    ///   &[2, 3],
-    /// ).unwrap();
-    /// let result = min(&x, 1.0, 2.0);
-    /// let expected = Tensor::<IntegerRep>::new(Some(&[2, 2, 2, 1, 1, -5]), &[2, 3]).unwrap();
-    /// assert_eq!(result, expected);
-    /// ```
-    pub fn min(a: &Tensor<IntegerRep>, scale_input: f64, threshold: f64) -> Tensor<IntegerRep> {
-        // calculate value of output
-        a.par_enum_map(|_, a_i| {
-            let d_inv_x = (a_i as f64) / scale_input;
-            let rounded = if d_inv_x >= threshold {
-                (threshold * scale_input).round() as IntegerRep
-            } else {
-                (d_inv_x * scale_input).round() as IntegerRep
-            };
-            Ok::<_, TensorError>(rounded)
-        })
-        .unwrap()
-    }
-
     /// Elementwise divides a tensor with a const integer element.
     /// # Arguments
     ///
@@ -2400,104 +2283,6 @@ pub mod nonlinearities {
         })
         .unwrap()
     }
-
-    /// Elementwise greater than
-    /// # Arguments
-    ///
-    /// * `a` - Tensor
-    /// * `b` - Single value
-    /// # Examples
-    /// ```
-    /// use ezkl::tensor::Tensor;
-    /// use ezkl::fieldutils::IntegerRep;
-    /// use ezkl::tensor::ops::nonlinearities::greater_than;
-    /// let x = Tensor::<IntegerRep>::new(
-    ///     Some(&[2, 1, 2, 7, 1, 1]),
-    ///     &[2, 3],
-    /// ).unwrap();
-    /// let k = 2.0;
-    /// let result = greater_than(&x, k);
-    /// let expected = Tensor::<IntegerRep>::new(Some(&[0, 0, 0, 1, 0, 0]), &[2, 3]).unwrap();
-    /// assert_eq!(result, expected);
-    /// ```
-    pub fn greater_than(a: &Tensor<IntegerRep>, b: f64) -> Tensor<IntegerRep> {
-        a.par_enum_map(|_, a_i| Ok::<_, TensorError>(IntegerRep::from((a_i as f64 - b) > 0_f64)))
-            .unwrap()
-    }
-
-    /// Elementwise greater than
-    /// # Arguments
-    ///
-    /// * `a` - Tensor
-    /// * `b` - Single value
-    /// # Examples
-    /// ```
-    /// use ezkl::tensor::Tensor;
-    /// use ezkl::fieldutils::IntegerRep;
-    /// use ezkl::tensor::ops::nonlinearities::greater_than_equal;
-    /// let x = Tensor::<IntegerRep>::new(
-    ///     Some(&[2, 1, 2, 7, 1, 1]),
-    ///     &[2, 3],
-    /// ).unwrap();
-    /// let k = 2.0;
-    /// let result = greater_than_equal(&x, k);
-    /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 0, 1, 1, 0, 0]), &[2, 3]).unwrap();
-    /// assert_eq!(result, expected);
-    /// ```
-    pub fn greater_than_equal(a: &Tensor<IntegerRep>, b: f64) -> Tensor<IntegerRep> {
-        a.par_enum_map(|_, a_i| Ok::<_, TensorError>(IntegerRep::from((a_i as f64 - b) >= 0_f64)))
-            .unwrap()
-    }
-
-    /// Elementwise less than
-    /// # Arguments
-    /// * `a` - Tensor
-    /// * `b` - Single value
-    /// # Examples
-    /// ```
-    /// use ezkl::tensor::Tensor;
-    /// use ezkl::fieldutils::IntegerRep;
-    /// use ezkl::tensor::ops::nonlinearities::less_than;
-    ///
-    /// let x = Tensor::<IntegerRep>::new(
-    ///    Some(&[2, 1, 2, 7, 1, 1]),
-    ///  &[2, 3],
-    /// ).unwrap();
-    /// let k = 2.0;
-    ///
-    /// let result = less_than(&x, k);
-    /// let expected = Tensor::<IntegerRep>::new(Some(&[0, 1, 0, 0, 1, 1]), &[2, 3]).unwrap();
-    /// assert_eq!(result, expected);
-    /// ```
-    pub fn less_than(a: &Tensor<IntegerRep>, b: f64) -> Tensor<IntegerRep> {
-        a.par_enum_map(|_, a_i| Ok::<_, TensorError>(IntegerRep::from((a_i as f64 - b) < 0_f64)))
-            .unwrap()
-    }
-
-    /// Elementwise less than
-    /// # Arguments
-    /// * `a` - Tensor
-    /// * `b` - Single value
-    /// # Examples
-    /// ```
-    /// use ezkl::tensor::Tensor;
-    /// use ezkl::fieldutils::IntegerRep;
-    /// use ezkl::tensor::ops::nonlinearities::less_than_equal;
-    ///
-    /// let x = Tensor::<IntegerRep>::new(
-    ///    Some(&[2, 1, 2, 7, 1, 1]),
-    ///  &[2, 3],
-    /// ).unwrap();
-    /// let k = 2.0;
-    ///
-    /// let result = less_than_equal(&x, k);
-    /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 1, 1, 0, 1, 1]), &[2, 3]).unwrap();
-    /// assert_eq!(result, expected);
-    /// ```
-    pub fn less_than_equal(a: &Tensor<IntegerRep>, b: f64) -> Tensor<IntegerRep> {
-        a.par_enum_map(|_, a_i| Ok::<_, TensorError>(IntegerRep::from((a_i as f64 - b) <= 0_f64)))
-            .unwrap()
-    }
 }
 
 /// Ops that return the transcript i.e intermediate calcs of an op

tests/assets/settings.json

@@ -27,7 +27,8 @@
         "check_mode": "UNSAFE",
         "commitment": "KZG",
         "decomp_base": 128,
-        "decomp_legs": 2
+        "decomp_legs": 2,
+        "bounded_log_lookup": false
     },
     "num_rows": 46,
     "total_assignments": 92,

tests/assets/witness.json

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

tests/integration_tests.rs

@@ -205,7 +205,7 @@ mod native_tests {
         "1l_tiny_div",
     ];
 
-    const TESTS: [&str; 95] = [
+    const TESTS: [&str; 96] = [
         "1l_mlp", //0
         "1l_slice",
         "1l_concat",
@@ -305,6 +305,7 @@ mod native_tests {
         "lstm_medium", // 92
         "lenet_5",     // 93
         "rsqrt",       // 94
+        "log",         // 95
     ];
 
     const WASM_TESTS: [&str; 46] = [
@@ -543,7 +544,7 @@ mod native_tests {
             }
         });
 
-            seq!(N in 0..=94 {
+            seq!(N in 0..=95 {
 
             #(#[test_case(TESTS[N])])*
             #[ignore]
@@ -852,9 +853,11 @@ mod native_tests {
             fn kzg_prove_and_verify_tight_lookup_(test: &str) {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
-                let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
+                let path = test_dir.into_path();
+                let path = path.to_str().unwrap();
+                crate::native_tests::mv_test_(path, test);
                prove_and_verify(path, test.to_string(), "safe", "private", "private", "public", 1, None, false, "single", Commitments::KZG, 1);
-               test_dir.close().unwrap();
+            //    test_dir.close().unwrap();
             }
 
             #(#[test_case(TESTS[N])])*
@@ -1632,7 +1635,6 @@ mod native_tests {
 
         let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(args)
-            .stdout(std::process::Stdio::null())
             .status()
             .expect("failed to execute process");
         assert!(status.success());