JSTprove 1.3.0__py3-none-macosx_11_0_arm64.whl → 2.0.0__py3-none-macosx_11_0_arm64.whl

{jstprove-1.3.0.dist-info → jstprove-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JSTprove
-Version: 1.3.0
+Version: 2.0.0
 Summary: Zero-knowledge proofs of ML inference on ONNX models
 Author: Inference Labs Inc
 Requires-Python: >=3.10
@@ -239,6 +239,10 @@ To keep paths simple (and to match our scripts), **clone Expander as a subfolder
 git clone https://github.com/PolyhedraZK/Expander.git
 cd Expander
 
+git fetch
+git checkout af1b7473bc858d250e481d6bb7db98a1ee6b7fc5
+
+
 # Build (uses the toolchain you configured with rustup)
 cargo build --release
 ```

{jstprove-1.3.0.dist-info → jstprove-2.0.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-jstprove-1.3.0.dist-info/licenses/LICENSE,sha256=UXQRcYRUH-PfN27n3P-FMaZFY6jr9jFPKcwT7CWbljw,1160
+jstprove-2.0.0.dist-info/licenses/LICENSE,sha256=UXQRcYRUH-PfN27n3P-FMaZFY6jr9jFPKcwT7CWbljw,1160
 python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python/core/__init__.py,sha256=RlfbqGAaUulKl44QGMCkkGJBQZ8R_AgC5bU5zS7BjnA,97
 python/core/binaries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python/core/binaries/expander-exec,sha256=C_1JcezdfLp9sFOQ2z3wp2gcq1k8zjIR09CxJKGGIuM,7095168
-python/core/binaries/onnx_generic_circuit_1-3-0,sha256=qbHC9SV_NuNv-vZs5MwXV0NxXkqTTZlmLH59WYCVrC8,3221088
+python/core/binaries/onnx_generic_circuit_2-0-0,sha256=mPtP1TSpMBtVw56vtGv7Gr7PztEwbdVQ5qwrg6pwDCM,3237712
 python/core/circuit_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python/core/circuit_models/generic_onnx.py,sha256=P65UZkfVBTE6YhaQ951S6QoTHPuU5ntDt8QL5pXghvw,8787
 python/core/circuit_models/simple_circuit.py,sha256=igQrZtQyreyHc26iAgCyDb0TuD2bJAoumYhc1pYPDzQ,4682
@@ -30,14 +30,14 @@ python/core/model_processing/onnx_quantizer/exceptions.py,sha256=vzxBRbpvk4ZZbga
 python/core/model_processing/onnx_quantizer/onnx_op_quantizer.py,sha256=5I67frJn4j2T1LTvODHixQK4VaqazJFJ0T1BCvqLPgg,9655
 python/core/model_processing/onnx_quantizer/layers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python/core/model_processing/onnx_quantizer/layers/add.py,sha256=AGxzqMa0jABIEKOIgPqEAA7EpZtynQtnD9nxI2NHc0s,1409
-python/core/model_processing/onnx_quantizer/layers/base.py,sha256=zUUAZpXCtbxbhHzuYczTNZPe-xWr6TxpmoAIDe4kCo4,21176
+python/core/model_processing/onnx_quantizer/layers/base.py,sha256=H48okaq1tvl6ckGZV6BlXCVLLKIy1HpvomGPWBLI-8Q,22544
 python/core/model_processing/onnx_quantizer/layers/batchnorm.py,sha256=KSBDPHd52f5Qyf-cnIDFPmfzssaJgMPiTmpIWEdM41U,7718
 python/core/model_processing/onnx_quantizer/layers/clip.py,sha256=HrhiLtqC3cIAvU0wRCqp8_8ZSFH8a3F1Jf_qkXlY44s,3043
 python/core/model_processing/onnx_quantizer/layers/constant.py,sha256=l1IvgvXkmFMiaBsym8wchPF-y1ZH-c5PmFUy92IXWok,3694
 python/core/model_processing/onnx_quantizer/layers/conv.py,sha256=TlUpCRO6PPqH7MPkIrEiEcVfzuiN1WMYEiNIjhYXtWM,4451
 python/core/model_processing/onnx_quantizer/layers/gemm.py,sha256=7fCUMv8OLVZ45a2lYjA2XNvcW3By7lSbX7zeForNK-0,3950
 python/core/model_processing/onnx_quantizer/layers/max.py,sha256=3gUxrdXwcVAtgR-_j4xQ0085Wj0oEBLT897TImxF2d4,1343
-python/core/model_processing/onnx_quantizer/layers/maxpool.py,sha256=PJ8hZPPBpfWV_RZdySl50-BU8TATjcg8Tg_mrAVS1Ic,4916
+python/core/model_processing/onnx_quantizer/layers/maxpool.py,sha256=NUa63fYNWrOy1zQMP8YFH_fknvh_3ZSMDfXU7xIJ9tc,7134
 python/core/model_processing/onnx_quantizer/layers/min.py,sha256=cQbXzGOApR6HUJZMARXy87W8IbUC562jnAQm8J8ynQI,1709
 python/core/model_processing/onnx_quantizer/layers/mul.py,sha256=qHsmnYPH-c5uiFeDCvV6e1xSgmIXJ64Sjvh0LYDYEqQ,1396
 python/core/model_processing/onnx_quantizer/layers/relu.py,sha256=d-5fyeKNLTgKKnqCwURpxkjl7QdbJQpuovtCFBM03FA,1685
@@ -98,7 +98,7 @@ python/tests/onnx_quantizer_tests/layers/factory.py,sha256=WLLEP9ECmSpTliSjhtdWO
 python/tests/onnx_quantizer_tests/layers/flatten_config.py,sha256=Xln5Hh6gyeM5gGRCjLGvIL-u08NEs1tXSF32urCqPfE,2110
 python/tests/onnx_quantizer_tests/layers/gemm_config.py,sha256=t7nJY-Wnj6YUD821-jaWzgrQVPa6ytwER3hFMsvyY6Y,7294
 python/tests/onnx_quantizer_tests/layers/max_config.py,sha256=vzR8-2wbPGcH0GMmAJ_sXSEdMtZOjVNGufU__N3Jfyw,3906
-python/tests/onnx_quantizer_tests/layers/maxpool_config.py,sha256=XfTPk_ZQXEzaCjHHymSLVv2HS-PKH1rS9IuyyoEtM78,3176
+python/tests/onnx_quantizer_tests/layers/maxpool_config.py,sha256=nQ7VQ5peq01ODrRoMl7HuMPN958juXteboD12dRsZS8,8275
 python/tests/onnx_quantizer_tests/layers/min_config.py,sha256=izKtCaMXoQHiAfmcGlJRQdKMQz3Su8n0p2mEn0y56Do,3774
 python/tests/onnx_quantizer_tests/layers/mul_config.py,sha256=_Oy4b97ORxFlF3w0BmJ94hNA968HQx2AvwYiASrGPxw,4135
 python/tests/onnx_quantizer_tests/layers/relu_config.py,sha256=_aHuddDApLUBOa0FiR9h4fNfmMSnH5r4JzOMLW0KaTk,2197
@@ -115,8 +115,8 @@ python/tests/onnx_quantizer_tests/layers_tests/test_scalability.py,sha256=RfnIIi
 python/tests/onnx_quantizer_tests/layers_tests/test_validation.py,sha256=jz-WtIEP-jjUklOOAnznwPUXbf07U2PAMGrhzMWP0JU,1371
 python/tests/utils_testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python/tests/utils_testing/test_helper_functions.py,sha256=xmeGQieh4LE9U-CDKBlHhSWqH0cAmmDU3qXNbDkkvms,27192
-jstprove-1.3.0.dist-info/METADATA,sha256=CqGuzrQWy_MUYtOcy-0i8mB_2eAKUvQ1R3tjEX-3N4o,14100
-jstprove-1.3.0.dist-info/WHEEL,sha256=jc2C2uw104ioj1TL9cE0YO67_kdAwX4W8JgYPomxr5M,105
-jstprove-1.3.0.dist-info/entry_points.txt,sha256=nGcTSO-4q08gPl1IoWdrPaiY7IbO7XvmXKkd34dYHc8,49
-jstprove-1.3.0.dist-info/top_level.txt,sha256=J-z0poNcsv31IHB413--iOY8LoHBKiTHeybHX3abokI,7
-jstprove-1.3.0.dist-info/RECORD,,
+jstprove-2.0.0.dist-info/METADATA,sha256=2y7oLbQStZnZoukzpTT8Avi5d3gTWtidjoo56IWVyCg,14166
+jstprove-2.0.0.dist-info/WHEEL,sha256=W0m4OUfxniOjS_4shj7CwgYZPxSrjpkVN6CH28tx5ZE,106
+jstprove-2.0.0.dist-info/entry_points.txt,sha256=nGcTSO-4q08gPl1IoWdrPaiY7IbO7XvmXKkd34dYHc8,49
+jstprove-2.0.0.dist-info/top_level.txt,sha256=J-z0poNcsv31IHB413--iOY8LoHBKiTHeybHX3abokI,7
+jstprove-2.0.0.dist-info/RECORD,,

{jstprove-1.3.0.dist-info → jstprove-2.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-macosx_11_0_arm64
 

python/core/model_processing/onnx_quantizer/layers/base.py

@@ -483,12 +483,13 @@ class QuantizerBase:
             node.input[:] = new_inputs
 
         # (2) Collect & merge attributes
+        self.apply_default_attrs(node)
         attrs = extract_attributes(node)
-        for k, v in self.DEFAULT_ATTRS.items():
-            attrs.setdefault(k, v)
         if self.USE_SCALING:
             attrs["rescale"] = int(scale_config.rescale)
 
+        attrs = self._serialize_quantized_attrs(attrs)
+
         # (3) Add scaling constant if needed
         if self.USE_SCALING:
             scale_value = self.get_scaling(scale_config.base, scale_config.exponent)
@@ -546,6 +547,7 @@ class QuantizerBase:
          - The resulting model will not make accurate prediction and should be
          used solely for analysis and keeping track of w_and_b
         """
+        self.apply_default_attrs(node)
         # If subclass does not want auto-scaling, do nothing
         if not getattr(self, "USE_WB", False):
             return
@@ -580,6 +582,47 @@ class QuantizerBase:
 
             initializer_map[tensor.name] = new_tensor
 
+    def apply_default_attrs(self, node: onnx.NodeProto) -> None:
+        """
+        Ensure DEFAULT_ATTRS are explicitly present on the node.
+        Does not overwrite existing attributes.
+        """
+        if not getattr(self, "DEFAULT_ATTRS", None):
+            return
+
+        existing = {attr.name for attr in node.attribute}
+
+        for name, value in self.DEFAULT_ATTRS.items():
+            if name in existing:
+                continue
+
+            try:
+                attr = onnx.helper.make_attribute(name, value)
+            except Exception as e:
+                raise HandlerImplementationError(
+                    op_type=node.op_type,
+                    message=f"Failed to create default attribute '{name}': {e}",
+                ) from e
+
+            node.attribute.append(attr)
+
+    def _serialize_quantized_attrs(self, attrs: dict) -> dict:
+        """
+        Convert logical attribute values into the serialized form expected
+        by quantized custom ops.
+
+        Lists are converted to comma-separated strings.
+        """
+        serialized = {}
+
+        for name, value in attrs.items():
+            if isinstance(value, list):
+                serialized[name] = ", ".join(str(v) for v in value)
+            else:
+                serialized[name] = value
+
+        return serialized
+
 
 class PassthroughQuantizer(BaseOpQuantizer):
     """

python/core/model_processing/onnx_quantizer/layers/maxpool.py

@@ -3,9 +3,12 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from typing import ClassVar
+
     import onnx
 
 from python.core.model_processing.onnx_custom_ops.onnx_helpers import (
+    extract_attributes,
     get_attribute_ints,
 )
 from python.core.model_processing.onnx_quantizer.exceptions import InvalidParamError
@@ -21,6 +24,12 @@ class QuantizeMaxpool(QuantizerBase):
     USE_WB = False
     USE_SCALING = False
 
+    DEFAULT_ATTRS: ClassVar = {
+        "dilations": [1],
+        "pads": [0],
+        "strides": [1],
+    }
+
 
 class MaxpoolQuantizer(BaseOpQuantizer, QuantizeMaxpool):
     """
@@ -72,6 +81,35 @@ class MaxpoolQuantizer(BaseOpQuantizer, QuantizeMaxpool):
             InvalidParamError: If any requirement is not met.
         """
         _ = initializer_map
+        attributes = extract_attributes(node)
+        ceil_mode = attributes.get("ceil_mode", None)
+        auto_pad = attributes.get("auto_pad", None)
+        storage_order = attributes.get("storage_order", None)
+
+        if ceil_mode != 0 and ceil_mode is not None:
+            raise InvalidParamError(
+                node.name,
+                node.op_type,
+                "ceil_mode must be 0",
+                "ceil_mode",
+                "0",
+            )
+        if auto_pad != "NOTSET" and auto_pad is not None:
+            raise InvalidParamError(
+                node.name,
+                node.op_type,
+                "auto_pad must be NOTSET",
+                "auto_pad",
+                "NOTSET",
+            )
+        if storage_order != 0 and storage_order is not None:
+            raise InvalidParamError(
+                node.name,
+                node.op_type,
+                "storage_order must be 0",
+                "storage_order",
+                "0",
+            )
         self.check_all_params_exist(node)
         self.check_params_size(node)
         self.check_pool_pads(node)
@@ -85,8 +123,8 @@ class MaxpoolQuantizer(BaseOpQuantizer, QuantizeMaxpool):
         Raises:
             InvalidParamError: If shape requirement is not met.
         """
-        # May need: ["strides", "kernel_shape", "pads", "dilations"]
-        required_attrs = ["strides", "kernel_shape"]
+        required_attrs = ["kernel_shape"]
+
         self.validate_required_attrs(node, required_attrs)
 
         # Check dimension of kernel
@@ -121,11 +159,23 @@ class MaxpoolQuantizer(BaseOpQuantizer, QuantizeMaxpool):
 
     def check_pool_pads(self: MaxpoolQuantizer, node: onnx.NodeProto) -> None:
         kernel_shape = get_attribute_ints(node, "kernel_shape", default=[])
-        pads = get_attribute_ints(node, "pads", default=None)
+        pads_raw = get_attribute_ints(
+            node,
+            "pads",
+            default=self.DEFAULT_ATTRS.get("pads", None),
+        )
+        pads = self.adjust_pads(node, pads_raw)
+
         if pads is None:
             return
         num_dims = len(kernel_shape)
-        if len(pads) != num_dims * 2:
+
+        if len(pads) == 1:
+            pads = pads * 2 * num_dims
+        elif len(pads) == num_dims:
+            # If only beginning pads given, repeat for end pads
+            pads = pads + pads
+        elif len(pads) != num_dims * 2:
             raise InvalidParamError(
                 node.name,
                 node.op_type,
@@ -148,3 +198,28 @@ class MaxpoolQuantizer(BaseOpQuantizer, QuantizeMaxpool):
                     node.op_type,
                     f"pads[{dim + num_dims}]={pad_after} >= kernel[{dim}]={kernel}",
                 )
+
+    def adjust_pads(
+        self: MaxpoolQuantizer,
+        node: onnx.NodeProto,
+        pads_raw: str | int | list[int] | None,
+    ) -> list[int]:
+        if pads_raw is None:
+            pads: list[int] = []
+        elif isinstance(pads_raw, str):
+            # single string, could be "0" or "1 2"
+            pads = [int(x) for x in pads_raw.split()]
+        elif isinstance(pads_raw, int):
+            # single integer
+            pads = [pads_raw]
+        elif isinstance(pads_raw, (list, tuple)):
+            # already a list of numbers (may be strings)
+            pads = [int(x) for x in pads_raw]
+        else:
+            raise InvalidParamError(
+                node.name,
+                node.op_type,
+                f"Cannot parse pads: {pads_raw}",
+            )
+
+        return pads

python/tests/onnx_quantizer_tests/layers/maxpool_config.py

@@ -28,6 +28,8 @@ class MaxPoolConfigProvider(BaseLayerConfigProvider):
                 "pads": [0, 0, 0, 0],
             },
             required_initializers={},
+            input_shapes={"input": [1, 3, 4, 4]},
+            output_shapes={"maxpool_output": [1, 3, 2, 2]},
         )
 
     def get_test_specs(self) -> list:
@@ -52,12 +54,97 @@ class MaxPoolConfigProvider(BaseLayerConfigProvider):
             .override_attrs(strides=[1, 1])
             .tags("stride_1", "pool", "overlap")
             .build(),
+            valid_test("missing_dilations_attr")
+            .description("MaxPool without dilations attribute should default to [1, 1]")
+            .override_attrs(dilations=None)
+            .tags("default_attr", "dilations", "pool")
+            .build(),
+            valid_test("non_default_dilations")
+            .description("MaxPool with explicit non-default dilations")
+            .override_attrs(dilations=[2, 2])
+            .tags("dilations", "non_default", "pool")
+            .override_output_shapes(maxpool_output=[1, 3, 1, 1])
+            .build(),
+            valid_test("missing_optional_attrs")
+            .description(
+                "MaxPool without pads/strides/dilations should use default values",
+            )
+            .override_attrs(
+                pads=None,
+                strides=None,
+                dilations=None,
+            )
+            .tags("defaults", "optional_attrs", "pool")
+            .build(),
+            valid_test("non_default_pads")
+            .description("MaxPool with explicit non-default pads")
+            .override_attrs(pads=[1, 1, 1, 1])
+            .override_output_shapes(maxpool_output=[1, 3, 3, 3])
+            .tags("pads", "non_default", "pool")
+            .build(),
+            valid_test("non_default_strides")
+            .description("MaxPool with explicit non-default strides [3, 3]")
+            .override_attrs(strides=[3, 3])
+            .override_output_shapes(maxpool_output=[1, 3, 1, 1])
+            .tags("strides", "non_default", "pool")
+            .build(),
+            valid_test("rectangular_strides")
+            .description("MaxPool with non-square strides [2, 1]")
+            .override_attrs(strides=[2, 1])
+            .override_output_shapes(maxpool_output=[1, 3, 2, 3])
+            .tags("strides", "non_square", "pool")
+            .build(),
+            # --- E2E TESTS ---
             e2e_test("e2e_basic")
             .description("End-to-end test for 2D MaxPool")
             .override_input_shapes(input=[1, 3, 4, 4])
             .override_output_shapes(maxpool_output=[1, 3, 2, 2])
             .tags("e2e", "pool", "2d")
             .build(),
+            e2e_test("missing_dilations_attr")
+            .description("MaxPool without dilations attribute should default to [1, 1]")
+            .override_attrs(dilations=None)
+            .tags("default_attr", "dilations", "pool")
+            .build(),
+            e2e_test("non_default_dilations")
+            .description("MaxPool with explicit non-default dilations")
+            .override_attrs(dilations=[2, 2])
+            .override_output_shapes(maxpool_output=[1, 3, 1, 1])
+            .tags("dilations", "non_default", "pool")
+            .build(),
+            e2e_test("e2e_defaults_applied")
+            .description("E2E MaxPool with default pads/strides/dilations applied")
+            .override_attrs(
+                pads=None,
+                strides=None,
+                dilations=None,
+            )
+            .override_input_shapes(input=[1, 1, 4, 4])
+            .override_output_shapes(maxpool_output=[1, 1, 3, 3])
+            .tags("e2e", "defaults", "pool")
+            .build(),
+            e2e_test("non_default_pads")
+            .description("MaxPool with explicit non-default pads")
+            .override_attrs(pads=[1, 1, 1, 1])
+            .override_output_shapes(maxpool_output=[1, 3, 3, 3])
+            .tags("pads", "non_default", "pool")
+            .build(),
+            e2e_test("non_default_strides")
+            .description("E2E MaxPool with explicit non-default strides")
+            .override_attrs(strides=[3, 3])
+            .override_input_shapes(input=[1, 3, 4, 4])
+            .override_output_shapes(maxpool_output=[1, 3, 1, 1])
+            .tags("e2e", "strides", "non_default", "pool")
+            .build(),
+            e2e_test("missing_strides_attr_defaults_applied")
+            .description(
+                "E2E MaxPool without strides attribute should default to [1, 1]",
+            )
+            .override_attrs(strides=None)
+            .override_input_shapes(input=[1, 1, 4, 4])
+            .override_output_shapes(maxpool_output=[1, 1, 3, 3])
+            .tags("e2e", "defaults", "strides", "pool")
+            .build(),
             # # --- ERROR TESTS ---
             error_test("asymmetric_padding")
             .description("MaxPool with asymmetric padding")
@@ -71,6 +158,25 @@ class MaxPoolConfigProvider(BaseLayerConfigProvider):
             .expects_error(InvalidParamError, "Currently only MaxPool2D is supported")
             .tags("invalid_attr_length", "kernel_shape")
             .build(),
+            error_test("auto_pad_not_supported")
+            .description("MaxPool with auto_pad should be rejected")
+            .override_attrs(auto_pad="SAME_UPPER")
+            .expects_error(InvalidParamError, "auto_pad must be NOTSET")
+            .tags("invalid", "auto_pad", "pool")
+            .build(),
+            error_test("ceil_mode_not_supported")
+            .description("MaxPool with ceil_mode != 0 should be rejected")
+            .override_attrs(ceil_mode=1)
+            .expects_error(InvalidParamError, "ceil_mode must be 0")
+            .tags("invalid", "ceil_mode", "pool")
+            .build(),
+            error_test("storage_order_not_supported")
+            .description("MaxPool with storage_order != 0 should be rejected")
+            .override_attrs(storage_order=1)
+            .expects_error(InvalidParamError, "storage_order must be 0")
+            .tags("invalid", "storage_order", "pool")
+            .build(),
+            # This can be removed if we start to support explicit None strides
             # --- EDGE CASE / SKIPPED TEST ---
             valid_test("large_input")
             .description("Large MaxPool input (performance/stress test)")