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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JSTprove
-Version: 2.0.0
+Version: 2.1.0
 Summary: Zero-knowledge proofs of ML inference on ONNX models
 Author: Inference Labs Inc
 Requires-Python: >=3.10

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

@@ -1,9 +1,9 @@
-jstprove-2.0.0.dist-info/licenses/LICENSE,sha256=UXQRcYRUH-PfN27n3P-FMaZFY6jr9jFPKcwT7CWbljw,1160
+jstprove-2.1.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_2-0-0,sha256=mPtP1TSpMBtVw56vtGv7Gr7PztEwbdVQ5qwrg6pwDCM,3237712
+python/core/binaries/onnx_generic_circuit_2-1-0,sha256=RAA6W15aObCMa-0FnwIFHyMStTAuhNJsiaE95dxTBPE,3323248
 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
@@ -15,7 +15,7 @@ python/core/model_processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 python/core/model_processing/errors.py,sha256=uh2YFjuuU5JM3anMtSTLAH-zjlNAKStmLDZqRUgBWS8,4611
 python/core/model_processing/converters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python/core/model_processing/converters/base.py,sha256=o6bNwmqD9sOM9taqMb0ed6804RugQiU3va0rY_EA5SE,4265
-python/core/model_processing/converters/onnx_converter.py,sha256=-eXdF6tfluFRxGgnQtJQ8R2309aYX-8z8HzMxk_Qv8I,44340
+python/core/model_processing/converters/onnx_converter.py,sha256=nAvcGzNqNJGHTUgdphvkQAg7JXBHMchIgzp-HTYAkJw,44353
 python/core/model_processing/onnx_custom_ops/__init__.py,sha256=ZKUC4ToRxgEEMHcTyERATVEN0KSDs-9cM1T-tTw3I1g,525
 python/core/model_processing/onnx_custom_ops/batchnorm.py,sha256=8kg4iGGdt6B_fIJkpt4v5eNFpoHa4bjTB0NnCSmKFvE,1693
 python/core/model_processing/onnx_custom_ops/conv.py,sha256=6jJm3fcGWzcU4RjVgf179mPFCqsl4C3AR7bqQTffDgA,3464
@@ -27,7 +27,7 @@ python/core/model_processing/onnx_custom_ops/onnx_helpers.py,sha256=utnJuc5sgb_z
 python/core/model_processing/onnx_custom_ops/relu.py,sha256=pZsPXC_r0FPggURKDphh8P1IRXY0w4hH7ExBmYTlWjE,1202
 python/core/model_processing/onnx_quantizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python/core/model_processing/onnx_quantizer/exceptions.py,sha256=vzxBRbpvk4ZZbgacDISnqmQQKj7Ls46V08ilHnhaJy0,5645
-python/core/model_processing/onnx_quantizer/onnx_op_quantizer.py,sha256=5I67frJn4j2T1LTvODHixQK4VaqazJFJ0T1BCvqLPgg,9655
+python/core/model_processing/onnx_quantizer/onnx_op_quantizer.py,sha256=fgN-2-oAqwu436yi_dvmdBApXq2T3DpKGZOqdZybjJ8,9996
 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=H48okaq1tvl6ckGZV6BlXCVLLKIy1HpvomGPWBLI-8Q,22544
@@ -41,7 +41,9 @@ python/core/model_processing/onnx_quantizer/layers/maxpool.py,sha256=NUa63fYNWrO
 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
+python/core/model_processing/onnx_quantizer/layers/squeeze.py,sha256=haQ9BaeE9w4XxBdTvKIuWSAhZ65Q7A7MhbZlzbFiyDE,4848
 python/core/model_processing/onnx_quantizer/layers/sub.py,sha256=M7D98TZBNP9-2R9MX6mcpYlrWFxTiX9JCs3XNcg1U-Q,1409
+python/core/model_processing/onnx_quantizer/layers/unsqueeze.py,sha256=qCS8BNsffDesseP15h2s9GDfw7Vg51XqZNVaTclKquQ,9807
 python/core/model_templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python/core/model_templates/circuit_template.py,sha256=OAqMRshi9OiJYoqpjkg5tUfNf18MfZmhsxxD6SANm_4,2106
 python/core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -54,10 +56,11 @@ python/core/utils/model_registry.py,sha256=aZg_9LEqsBXK84oxQ8A3NGZl-9aGnLgfR-kgx
 python/core/utils/scratch_tests.py,sha256=o2VDTk8QBKA3UHHE-h7Ghtoge6kGG7G-8qwvesuTFFc,2281
 python/core/utils/witness_utils.py,sha256=ukvbF6EaHMPzRQVZad9wQ9gISRwBGQ1hEAHzc5TpGuw,9488
 python/frontend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python/frontend/cli.py,sha256=lkvhzQC6bv0AgWUypg_cH-JT574r89qgTIsgHDT9GRg,3106
-python/frontend/commands/__init__.py,sha256=HKfKIM8wKMvzUPlBMJCSAqRurPIp85btGFCNjr7DbyE,575
+python/frontend/cli.py,sha256=HU0nYkp0kFgxP1BCs_CX4ERd7VvqzKFMooBK5LkEK2c,3142
+python/frontend/commands/__init__.py,sha256=b6N5jB72TbacBNTraYwqFCei8gepw06id8skZOkKMOw,651
 python/frontend/commands/args.py,sha256=JmG4q-tbEy8_YcQsph_WLEAs_w7y7GiR22PhTrc14v4,2255
 python/frontend/commands/base.py,sha256=a7NWoXB9VL8It1TpuL2vmR7J2bhejHDllrNMBEm-JLE,6368
+python/frontend/commands/batch.py,sha256=-uy1PLgeEDIzgRet8JPcUb2xTkrQHW3v_x0_om7hr6U,6069
 python/frontend/commands/compile.py,sha256=-mE4LjBEXzgsnzTJCeas0ZkZgD-kdATpYLk52ljBw88,1905
 python/frontend/commands/constants.py,sha256=feCVczqP6xphHUta2ZMaAuYyVeemZgwU_sCWr6ky5X8,164
 python/frontend/commands/model_check.py,sha256=xsXvXzYpIagFGnUk_UYGZYx-onP0Opes95XismqvY64,1806
@@ -72,7 +75,7 @@ python/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python/scripts/benchmark_runner.py,sha256=sjbqaLrdjt94AoyQXAxT4FhsN6aRu5idTRQ5uHmZOWM,28593
 python/scripts/gen_and_bench.py,sha256=V36x7djYmHlveAJgYzMlXwnmF0gAGO3-1mg9PWOmpj8,16249
 python/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python/tests/test_cli.py,sha256=OiAyG3aBpukk0i5FFWbiKaF42wf-7By-UWDHNjwtsqo,27042
+python/tests/test_cli.py,sha256=hhlhsEx-6jJEtw4SKwZFBki5iKs8Z8KPtQccxgy1AMo,31755
 python/tests/circuit_e2e_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python/tests/circuit_e2e_tests/circuit_model_developer_test.py,sha256=8hl8SKw7obXplo0jsiKoKIZLxlu1_HhXvGDeSBDBars,39456
 python/tests/circuit_e2e_tests/helper_fns_for_tests.py,sha256=uEThqTsRdNJivHwAv-aJIUtSPlmVHdhMZqZSH1OqhDE,5177
@@ -89,7 +92,7 @@ python/tests/onnx_quantizer_tests/test_registered_quantizers.py,sha256=lw_jYSbQ9
 python/tests/onnx_quantizer_tests/testing_helper_functions.py,sha256=N0fQv2pYzUCVZ7wkcR8gEKs5zTXT1hWrK-HKSTQYvYU,534
 python/tests/onnx_quantizer_tests/layers/__init__.py,sha256=xP-RmW6LfIANgK1s9Q0KZet2yvNr-3c6YIVLAAQqGUY,404
 python/tests/onnx_quantizer_tests/layers/add_config.py,sha256=T3tGddupDtrvLck2SL2yETDblNtv0aU7Tl7fNyZUhO4,4133
-python/tests/onnx_quantizer_tests/layers/base.py,sha256=3nqmU2PgOdK_mPkz-YHg3idgr-PXYbu5kCIY-Uic5yo,9317
+python/tests/onnx_quantizer_tests/layers/base.py,sha256=YbUx0CnGGtET9qsOd1aD2oN5GbhC6MYtguONp6fY6BA,9327
 python/tests/onnx_quantizer_tests/layers/batchnorm_config.py,sha256=P-sZuHAdEfNczcgTeLjqJnEbpqN3dKTsbqvY4-SBqiQ,8231
 python/tests/onnx_quantizer_tests/layers/clip_config.py,sha256=-OuhnUgz6xY4iW1jUR7W-J__Ie9lXI9vplmzp8qXqRc,4973
 python/tests/onnx_quantizer_tests/layers/constant_config.py,sha256=RdrKNMNZjI3Sk5o8WLNqmBUyYVJRWgtFbQ6oFWMwyQk,1193
@@ -103,7 +106,9 @@ python/tests/onnx_quantizer_tests/layers/min_config.py,sha256=izKtCaMXoQHiAfmcGl
 python/tests/onnx_quantizer_tests/layers/mul_config.py,sha256=_Oy4b97ORxFlF3w0BmJ94hNA968HQx2AvwYiASrGPxw,4135
 python/tests/onnx_quantizer_tests/layers/relu_config.py,sha256=_aHuddDApLUBOa0FiR9h4fNfmMSnH5r4JzOMLW0KaTk,2197
 python/tests/onnx_quantizer_tests/layers/reshape_config.py,sha256=fZchSqIAy76m7j97wVC_UI6slSpv8nbwukhkbGR2sRE,2203
+python/tests/onnx_quantizer_tests/layers/squeeze_config.py,sha256=6Grn9yzgQzrLtjA5fs6E_DNZxtsyDfIqmwpr9l2jric,4909
 python/tests/onnx_quantizer_tests/layers/sub_config.py,sha256=IxF18mG9kjlEiKYSNG912CEcBxOFGxIWoRAwjvBXiRo,4133
+python/tests/onnx_quantizer_tests/layers/unsqueeze_config.py,sha256=M707k0pFvlZOeehkE9TWurPNrYwlaH-IjjV6mZdFEPM,4782
 python/tests/onnx_quantizer_tests/layers_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python/tests/onnx_quantizer_tests/layers_tests/base_test.py,sha256=UgbcT97tgcuTtO1pOADpww9bz_JElKiI2mxLJYKyF1k,2992
 python/tests/onnx_quantizer_tests/layers_tests/test_check_model.py,sha256=Vxn4LEWHZeGa_vS1-7ptFqSSBb0D-3BG-ETocP4pvsI,3651
@@ -115,8 +120,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-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-2.1.0.dist-info/METADATA,sha256=dbpJDcKKKd0J8pLcyiz4f4Ohac7EI6GVK6muJf2Y52k,14166
+jstprove-2.1.0.dist-info/WHEEL,sha256=W0m4OUfxniOjS_4shj7CwgYZPxSrjpkVN6CH28tx5ZE,106
+jstprove-2.1.0.dist-info/entry_points.txt,sha256=nGcTSO-4q08gPl1IoWdrPaiY7IbO7XvmXKkd34dYHc8,49
+jstprove-2.1.0.dist-info/top_level.txt,sha256=J-z0poNcsv31IHB413--iOY8LoHBKiTHeybHX3abokI,7
+jstprove-2.1.0.dist-info/RECORD,,

python/core/model_processing/converters/onnx_converter.py

@@ -1022,7 +1022,9 @@ class ONNXConverter(ModelConverter):
         ]
         self.input_shape = get_input_shapes(onnx_model)
 
-    def get_weights(self: ONNXConverter) -> tuple[
+    def get_weights(
+        self: ONNXConverter,
+    ) -> tuple[
         dict[str, list[ONNXLayerDict]],
         dict[str, list[ONNXLayerDict]],
         CircuitParamsDict,
@@ -1055,7 +1057,7 @@ class ONNXConverter(ModelConverter):
             scale_base=scale_base,
         )
         # Get layers in correct format
-        (architecture, w_and_b) = self.analyze_layers(
+        architecture, w_and_b = self.analyze_layers(
             scaled_and_transformed_model,
             output_name_to_shape,
         )

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

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+import numpy as np
+from onnx import numpy_helper
+
+from python.core.model_processing.onnx_quantizer.exceptions import (
+    InvalidParamError,
+)
+from python.core.model_processing.onnx_quantizer.layers.base import (
+    BaseOpQuantizer,
+    QuantizerBase,
+    ScaleConfig,
+)
+
+if TYPE_CHECKING:
+    import onnx
+
+
+class QuantizeSqueeze(QuantizerBase):
+    OP_TYPE = "Squeeze"
+    DOMAIN = ""
+    USE_WB = False
+    USE_SCALING = False
+    # Only the data input is relevant for scale-planning.
+    SCALE_PLAN: ClassVar = {0: 1}
+
+
+class SqueezeQuantizer(BaseOpQuantizer, QuantizeSqueeze):
+    """
+    Quantizer for ONNX Squeeze.
+
+    Squeeze is scale-preserving (pure shape/view transform):
+    - No arithmetic
+    - No rescaling
+    - No custom op
+
+    We support:
+    - axes as an attribute (older opsets)
+    - axes as a constant initializer input (newer opsets)
+
+    We do NOT support dynamic axes provided at runtime.
+    """
+
+    def __init__(
+        self: SqueezeQuantizer,
+        new_initializers: list[onnx.TensorProto] | None = None,
+    ) -> None:
+        super().__init__()
+        if new_initializers is not None:
+            self.new_initializers = new_initializers
+
+    def quantize(
+        self: SqueezeQuantizer,
+        node: onnx.NodeProto,
+        graph: onnx.GraphProto,
+        scale_config: ScaleConfig,
+        initializer_map: dict[str, onnx.TensorProto],
+    ) -> list[onnx.NodeProto]:
+        # Pure passthrough; QuantizerBase handles standard bookkeeping.
+        return QuantizeSqueeze.quantize(
+            self,
+            node,
+            graph,
+            scale_config,
+            initializer_map,
+        )
+
+    _N_INPUTS_NO_AXES: ClassVar[int] = 1
+    _N_INPUTS_WITH_AXES: ClassVar[int] = 2
+
+    def _get_axes_from_attribute(self, node: onnx.NodeProto) -> list[int] | None:
+        for attr in node.attribute:
+            if attr.name == "axes":
+                return list(attr.ints)
+        return None
+
+    def _get_axes_from_initializer_input(
+        self,
+        node: onnx.NodeProto,
+        initializer_map: dict[str, onnx.TensorProto],
+    ) -> list[int]:
+        axes_name = node.input[1]
+        if axes_name not in initializer_map:
+            raise InvalidParamError(
+                node_name=node.name,
+                op_type=node.op_type,
+                message=(
+                    f"Dynamic axes input is not supported for Squeeze "
+                    f"(expected axes '{axes_name}' to be an initializer)."
+                ),
+            )
+
+        axes_tensor = initializer_map[axes_name]
+        arr = numpy_helper.to_array(axes_tensor)
+
+        if not np.issubdtype(arr.dtype, np.integer):
+            raise InvalidParamError(
+                node_name=node.name,
+                op_type=node.op_type,
+                message=f"Squeeze axes initializer must be integer, got {arr.dtype}.",
+                attr_key="axes",
+                expected="integer tensor (0-D or 1-D)",
+            )
+
+        if arr.ndim == 0:
+            return [int(arr)]
+        if arr.ndim == 1:
+            return [int(x) for x in arr.tolist()]
+
+        raise InvalidParamError(
+            node_name=node.name,
+            op_type=node.op_type,
+            message=f"Squeeze axes initializer must be 0-D or 1-D, got {arr.ndim}-D.",
+            attr_key="axes",
+            expected="0-D scalar or 1-D list of axes",
+        )
+
+    def check_supported(
+        self: SqueezeQuantizer,
+        node: onnx.NodeProto,
+        initializer_map: dict[str, onnx.TensorProto] | None = None,
+    ) -> None:
+        self.validate_node_has_output(node)
+        initializer_map = initializer_map or {}
+
+        n_inputs = len(node.input)
+        if n_inputs not in (self._N_INPUTS_NO_AXES, self._N_INPUTS_WITH_AXES):
+            raise InvalidParamError(
+                node_name=node.name,
+                op_type=node.op_type,
+                message=f"Squeeze expects 1 or 2 inputs, got {n_inputs}.",
+            )
+
+        axes = self._get_axes_from_attribute(node)
+
+        # If axes is provided as a second input, it must be a constant initializer.
+        if axes is None and n_inputs == self._N_INPUTS_WITH_AXES:
+            axes = self._get_axes_from_initializer_input(node, initializer_map)
+
+        # If axes is omitted entirely, ONNX semantics are "remove all dims of size 1".
+        # We can't validate legality here without rank/shape; defer to Rust.
+
+        if axes is None:
+            return
+
+        if len(set(axes)) != len(axes):
+            raise InvalidParamError(
+                node_name=node.name,
+                op_type=node.op_type,
+                message=f"axes must not contain duplicates: {axes}",
+                attr_key="axes",
+                expected="axes list with unique entries",
+            )

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

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+import numpy as np
+from onnx import helper, numpy_helper
+
+from python.core.model_processing.converters.base import ModelType
+from python.core.model_processing.errors import LayerAnalysisError
+from python.core.model_processing.onnx_custom_ops.onnx_helpers import parse_attributes
+from python.core.model_processing.onnx_quantizer.exceptions import (
+    InvalidParamError,
+)
+from python.core.model_processing.onnx_quantizer.layers.base import (
+    BaseOpQuantizer,
+    QuantizerBase,
+    ScaleConfig,
+)
+
+if TYPE_CHECKING:
+    import onnx
+
+_N_UNSQUEEZE_INPUTS: int = 2
+
+
+class QuantizeUnsqueeze(QuantizerBase):
+    OP_TYPE = "Unsqueeze"
+    DOMAIN = ""
+    USE_WB = False
+    USE_SCALING = False
+    # Only the data input is relevant for scale-planning.
+    SCALE_PLAN: ClassVar = {0: 1}
+
+
+class UnsqueezeQuantizer(BaseOpQuantizer, QuantizeUnsqueeze):
+    """
+    Quantizer for ONNX Unsqueeze.
+
+    Unsqueeze is scale-preserving (pure shape/view transform):
+    - No arithmetic
+    - No rescaling
+    - No custom op
+
+    Semantics:
+    - Inserts new dimensions of size 1 at the specified axes positions.
+
+    We support:
+    - axes as an attribute (older opsets)
+    - axes as a constant initializer input (opset >= 13 style)
+
+    We do NOT support dynamic axes provided at runtime.
+    """
+
+    def __init__(
+        self: UnsqueezeQuantizer,
+        new_initializers: list[onnx.TensorProto] | None = None,
+    ) -> None:
+        super().__init__()
+        if new_initializers is not None:
+            self.new_initializers = new_initializers
+
+    def quantize(
+        self: UnsqueezeQuantizer,
+        node: onnx.NodeProto,
+        graph: onnx.GraphProto,
+        scale_config: ScaleConfig,
+        initializer_map: dict[str, onnx.TensorProto],
+    ) -> list[onnx.NodeProto]:
+        # Pure passthrough; QuantizerBase handles standard bookkeeping.
+        return QuantizeUnsqueeze.quantize(
+            self,
+            node,
+            graph,
+            scale_config,
+            initializer_map,
+        )
+
+    def pre_analysis_transform(
+        self: UnsqueezeQuantizer,
+        node: onnx.NodeProto,
+        graph: onnx.GraphProto,
+        initializer_map: dict[str, onnx.TensorProto],
+        scale_base: int,
+        scale_exponent: int,
+    ) -> None:
+        _ = initializer_map, scale_base, scale_exponent
+        model_type = ModelType.ONNX
+        params = parse_attributes(node.attribute)
+        if node.op_type != "Unsqueeze":
+            return
+        if params and "axes" in params:
+            return
+        axes = _extract_unsqueeze_axes_into_params(
+            name=node.name,
+            inputs=node.input,
+            params=params,
+            graph=graph,
+            model_type=model_type,
+            initializer_map=initializer_map,
+        )
+        attr = helper.make_attribute("axes", axes["axes"])
+        node.attribute.append(attr)
+
+    _N_INPUTS_NO_AXES: ClassVar[int] = 1
+    _N_INPUTS_WITH_AXES: ClassVar[int] = 2
+
+    def _get_axes_from_attribute(self, node: onnx.NodeProto) -> list[int] | None:
+        for attr in node.attribute:
+            if attr.name == "axes":
+                return list(attr.ints)
+        return None
+
+    def _get_axes_from_initializer_input(
+        self,
+        node: onnx.NodeProto,
+        initializer_map: dict[str, onnx.TensorProto],
+    ) -> list[int]:
+        axes_name = node.input[1]
+        if axes_name not in initializer_map:
+            raise InvalidParamError(
+                node_name=node.name,
+                op_type=node.op_type,
+                message=(
+                    f"Dynamic axes input is not supported for Unsqueeze "
+                    f"(expected axes '{axes_name}' to be an initializer)."
+                ),
+            )
+
+        axes_tensor = initializer_map[axes_name]
+        arr = numpy_helper.to_array(axes_tensor)
+
+        if not np.issubdtype(arr.dtype, np.integer):
+            raise InvalidParamError(
+                node_name=node.name,
+                op_type=node.op_type,
+                message=f"Unsqueeze axes initializer must be integer, got {arr.dtype}.",
+                attr_key="axes",
+                expected="integer tensor (0-D or 1-D)",
+            )
+
+        if arr.ndim == 0:
+            return [int(arr)]
+        if arr.ndim == 1:
+            return [int(x) for x in arr.tolist()]
+
+        raise InvalidParamError(
+            node_name=node.name,
+            op_type=node.op_type,
+            message=f"Unsqueeze axes initializer must be 0-D or 1-D, got {arr.ndim}-D.",
+            attr_key="axes",
+            expected="0-D scalar or 1-D list of axes",
+        )
+
+    def check_supported(
+        self: UnsqueezeQuantizer,
+        node: onnx.NodeProto,
+        initializer_map: dict[str, onnx.TensorProto] | None = None,
+    ) -> None:
+        self.validate_node_has_output(node)
+        initializer_map = initializer_map or {}
+
+        n_inputs = len(node.input)
+        if n_inputs not in (self._N_INPUTS_NO_AXES, self._N_INPUTS_WITH_AXES):
+            raise InvalidParamError(
+                node_name=node.name,
+                op_type=node.op_type,
+                message=(
+                    "Unsqueeze expects either 1 input (axes as attribute) or 2 inputs "
+                    f"(axes as initializer), got {n_inputs}."
+                ),
+            )
+
+        axes = self._get_axes_from_attribute(node)
+
+        # ONNX Unsqueeze has two schema styles:
+        #  - newer: Unsqueeze(data, axes) -> 2 inputs, axes is initializer input
+        #  - older: Unsqueeze(data) with axes attribute -> 1 input
+        if n_inputs == self._N_INPUTS_NO_AXES:
+            if axes is None:
+                raise InvalidParamError(
+                    node_name=node.name,
+                    op_type=node.op_type,
+                    message=(
+                        "Unsqueeze with 1 input is only supported when 'axes' is "
+                        "provided as an attribute (older opsets)."
+                    ),
+                    attr_key="axes",
+                    expected="axes attribute",
+                )
+        elif axes is None:
+            axes = self._get_axes_from_initializer_input(node, initializer_map)
+
+        if axes is None:
+            raise InvalidParamError(
+                node_name=node.name,
+                op_type=node.op_type,
+                message="Unsqueeze requires 'axes' to be provided.",
+                attr_key="axes",
+                expected="axes attribute or initializer input",
+            )
+
+        if len(set(axes)) != len(axes):
+            raise InvalidParamError(
+                node_name=node.name,
+                op_type=node.op_type,
+                message=f"axes must not contain duplicates: {axes}",
+                attr_key="axes",
+                expected="axes list with unique entries",
+            )
+
+
+def _extract_unsqueeze_axes_into_params(  # noqa: PLR0913
+    *,
+    name: str,
+    inputs: list[str] | tuple[str, ...],
+    params: dict | None,
+    graph: onnx.GraphProto,
+    model_type: ModelType,
+    initializer_map: dict[str, onnx.TensorProto] | None = None,
+) -> dict:
+    if len(inputs) != _N_UNSQUEEZE_INPUTS:
+        msg = (
+            f"Unsqueeze '{name}' is missing axes input. "
+            f"Expected 2 inputs (data, axes), got {len(inputs)}: {list(inputs)}"
+        )
+        raise LayerAnalysisError(model_type=model_type, reason=msg)
+
+    axes_name = inputs[1]
+
+    axes_arr = _resolve_unsqueeze_axes_array(
+        name=name,
+        axes_name=axes_name,
+        graph=graph,
+        model_type=model_type,
+        initializer_map=initializer_map,
+    )
+
+    _validate_unsqueeze_axes_are_integer(
+        name=name,
+        axes_arr=axes_arr,
+        model_type=model_type,
+    )
+
+    out_params = params or {}
+    out_params["axes"] = _axes_array_to_int_list(axes_arr)
+    return out_params
+
+
+def _resolve_unsqueeze_axes_array(
+    *,
+    name: str,
+    axes_name: str,
+    graph: onnx.GraphProto,
+    model_type: ModelType,
+    initializer_map: dict[str, onnx.TensorProto] | None = None,
+) -> np.ndarray:
+    if not initializer_map:
+        initializer_map = {init.name: init for init in graph.initializer}
+
+    if axes_name in initializer_map:
+        return numpy_helper.to_array(initializer_map[axes_name])
+
+    const_tensor = _find_constant_tensor_by_output_name(
+        graph=graph,
+        output_name=axes_name,
+    )
+
+    if const_tensor is not None:
+        return numpy_helper.to_array(const_tensor)
+
+    msg = (
+        f"Unsqueeze '{name}' has dynamic axes input '{axes_name}'. "
+        "Only constant initializer axes or Constant-node axes are supported."
+    )
+    raise LayerAnalysisError(model_type=model_type, reason=msg)
+
+
+def _find_constant_tensor_by_output_name(
+    *,
+    graph: onnx.GraphProto,
+    output_name: str,
+) -> onnx.TensorProto | None:
+    for n in graph.node:
+        if n.op_type != "Constant" or not n.output:
+            continue
+        if n.output[0] != output_name:
+            continue
+
+        for attr in n.attribute:
+            if attr.name == "value" and attr.t is not None:
+                return attr.t
+
+        # Constant node exists but doesn't have the expected tensor attribute.
+        return None
+
+    return None
+
+
+def _validate_unsqueeze_axes_are_integer(
+    *,
+    name: str,
+    axes_arr: np.ndarray,
+    model_type: ModelType,
+) -> None:
+    if not np.issubdtype(axes_arr.dtype, np.integer):
+        msg = f"Unsqueeze '{name}' axes must be integer, got dtype {axes_arr.dtype}."
+        raise LayerAnalysisError(model_type=model_type, reason=msg)
+
+
+def _axes_array_to_int_list(axes_arr: np.ndarray) -> list[int]:
+    if axes_arr.ndim == 0:
+        return [int(axes_arr)]
+    return [int(x) for x in axes_arr.reshape(-1).tolist()]

python/core/model_processing/onnx_quantizer/onnx_op_quantizer.py

@@ -31,7 +31,11 @@ from python.core.model_processing.onnx_quantizer.layers.maxpool import MaxpoolQu
 from python.core.model_processing.onnx_quantizer.layers.min import MinQuantizer
 from python.core.model_processing.onnx_quantizer.layers.mul import MulQuantizer
 from python.core.model_processing.onnx_quantizer.layers.relu import ReluQuantizer
+from python.core.model_processing.onnx_quantizer.layers.squeeze import SqueezeQuantizer
 from python.core.model_processing.onnx_quantizer.layers.sub import SubQuantizer
+from python.core.model_processing.onnx_quantizer.layers.unsqueeze import (
+    UnsqueezeQuantizer,
+)
 
 
 class ONNXOpQuantizer:
@@ -90,6 +94,8 @@ class ONNXOpQuantizer:
         self.register("Max", MaxQuantizer(self.new_initializers))
         self.register("Min", MinQuantizer(self.new_initializers))
         self.register("BatchNormalization", BatchnormQuantizer(self.new_initializers))
+        self.register("Squeeze", SqueezeQuantizer(self.new_initializers))
+        self.register("Unsqueeze", UnsqueezeQuantizer(self.new_initializers))
 
     def register(
         self: ONNXOpQuantizer,

python/frontend/cli.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from python.frontend.commands import BaseCommand
 
 from python.frontend.commands import (
+    BatchCommand,
     BenchCommand,
     CompileCommand,
     ModelCheckCommand,
@@ -41,6 +42,7 @@ COMMANDS: list[type[BaseCommand]] = [
     WitnessCommand,
     ProveCommand,
     VerifyCommand,
+    BatchCommand,
     BenchCommand,
 ]
 

python/frontend/commands/__init__.py

@@ -1,4 +1,5 @@
 from python.frontend.commands.base import BaseCommand
+from python.frontend.commands.batch import BatchCommand
 from python.frontend.commands.bench import BenchCommand
 from python.frontend.commands.compile import CompileCommand
 from python.frontend.commands.model_check import ModelCheckCommand
@@ -8,6 +9,7 @@ from python.frontend.commands.witness import WitnessCommand
 
 __all__ = [
     "BaseCommand",
+    "BatchCommand",
     "BenchCommand",
     "CompileCommand",
     "ModelCheckCommand",

python/frontend/commands/batch.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from python.core.utils.helper_functions import (
+    read_from_json,
+    run_cargo_command,
+    to_json,
+)
+from python.frontend.commands.args import CIRCUIT_PATH
+from python.frontend.commands.base import BaseCommand
+
+if TYPE_CHECKING:
+    import argparse
+    from collections.abc import Callable
+
+    from python.core.circuits.base import Circuit
+
+
+def _preprocess_manifest(
+    circuit: Circuit,
+    manifest_path: str,
+    circuit_path: str,
+    transform_job: Callable[[Circuit, dict[str, Any]], None],
+) -> str:
+    circuit_file = Path(circuit_path)
+    quantized_path = str(
+        circuit_file.parent / f"{circuit_file.stem}_quantized_model.onnx",
+    )
+    circuit.load_quantized_model(quantized_path)
+
+    manifest: dict[str, Any] = read_from_json(manifest_path)
+    if not isinstance(manifest, dict) or not isinstance(
+        manifest.get("jobs"),
+        list,
+    ):
+        msg = f"Invalid manifest: expected {{'jobs': [...]}} in {manifest_path}"
+        raise TypeError(msg)
+    for job in manifest["jobs"]:
+        transform_job(circuit, job)
+
+    manifest_file = Path(manifest_path)
+    processed_path = str(
+        manifest_file.with_name(
+            manifest_file.stem + "_processed" + manifest_file.suffix,
+        ),
+    )
+    to_json(manifest, processed_path)
+    return processed_path
+
+
+def _validate_job_keys(job: dict[str, Any], *keys: str) -> None:
+    missing = [k for k in keys if k not in job]
+    if missing:
+        msg = f"Job missing required keys {missing}: {job}"
+        raise ValueError(msg)
+
+
+def _transform_witness_job(circuit: Circuit, job: dict[str, Any]) -> None:
+    _validate_job_keys(job, "input", "output")
+    inputs = read_from_json(job["input"])
+    scaled = circuit.scale_inputs_only(inputs)
+
+    inference_inputs = circuit.reshape_inputs_for_inference(scaled)
+    circuit_inputs = circuit.reshape_inputs_for_circuit(scaled)
+
+    path = Path(job["input"])
+    adjusted_path = str(path.with_name(path.stem + "_adjusted" + path.suffix))
+    to_json(circuit_inputs, adjusted_path)
+
+    outputs = circuit.get_outputs(inference_inputs)
+    formatted = circuit.format_outputs(outputs)
+    to_json(formatted, job["output"])
+
+    job["input"] = adjusted_path
+
+
+def _transform_verify_job(circuit: Circuit, job: dict[str, Any]) -> None:
+    _validate_job_keys(job, "input")
+    inputs = read_from_json(job["input"])
+    circuit_inputs = circuit.reshape_inputs_for_circuit(inputs)
+
+    path = Path(job["input"])
+    processed_path = str(path.with_name(path.stem + "_veri" + path.suffix))
+    to_json(circuit_inputs, processed_path)
+
+    job["input"] = processed_path
+
+
+class BatchCommand(BaseCommand):
+    """Run batch operations on multiple inputs."""
+
+    name: ClassVar[str] = "batch"
+    aliases: ClassVar[list[str]] = []
+    help: ClassVar[str] = "Run batch witness/prove/verify operations."
+
+    @classmethod
+    def _add_batch_args(cls, subparser: argparse.ArgumentParser) -> None:
+        CIRCUIT_PATH.add_to_parser(subparser)
+        subparser.add_argument(
+            "-f",
+            "--manifest",
+            required=True,
+            help="Path to batch manifest JSON file.",
+        )
+
+    @classmethod
+    def configure_parser(
+        cls: type[BatchCommand],
+        parser: argparse.ArgumentParser,
+    ) -> None:
+        subparsers = parser.add_subparsers(dest="batch_mode", required=True)
+
+        for name, help_text in [
+            ("witness", "Generate witnesses for multiple inputs."),
+            ("prove", "Generate proofs for multiple witnesses."),
+            ("verify", "Verify multiple proofs."),
+        ]:
+            sub = subparsers.add_parser(name, help=help_text)
+            cls._add_batch_args(sub)
+
+    @classmethod
+    def run(cls: type[BatchCommand], args: argparse.Namespace) -> None:
+        circuit_path = getattr(args, "circuit_path", None) or getattr(
+            args,
+            "pos_circuit_path",
+            None,
+        )
+        if not circuit_path:
+            msg = "Missing required argument: circuit_path"
+            raise ValueError(msg)
+
+        circuit_file = Path(circuit_path)
+        if not circuit_file.is_file():
+            msg = f"Circuit file not found: {circuit_path}"
+            raise FileNotFoundError(msg)
+
+        manifest_path = args.manifest
+        if not Path(manifest_path).is_file():
+            msg = f"Manifest file not found: {manifest_path}"
+            raise FileNotFoundError(msg)
+
+        batch_mode = args.batch_mode
+
+        circuit = cls._build_circuit("cli")
+
+        run_type_map = {
+            "witness": "run_batch_witness",
+            "prove": "run_batch_prove",
+            "verify": "run_batch_verify",
+        }
+
+        run_type_str = run_type_map.get(batch_mode)
+        if not run_type_str:
+            msg = f"Unknown batch mode: {batch_mode}"
+            raise ValueError(msg)
+
+        circuit_dir = circuit_file.parent
+        name = circuit_file.stem
+        metadata_path = str(circuit_dir / f"{name}_metadata.json")
+        if not Path(metadata_path).is_file():
+            msg = f"Metadata file not found: {metadata_path}"
+            raise FileNotFoundError(msg)
+
+        preprocess_map = {
+            "witness": _transform_witness_job,
+            "verify": _transform_verify_job,
+        }
+        if batch_mode in preprocess_map:
+            manifest_path = _preprocess_manifest(
+                circuit,
+                manifest_path,
+                circuit_path,
+                preprocess_map[batch_mode],
+            )
+
+        try:
+            run_cargo_command(
+                binary_name=circuit.name,
+                command_type=run_type_str,
+                args={
+                    "c": circuit_path,
+                    "f": manifest_path,
+                    "m": metadata_path,
+                },
+                dev_mode=False,
+            )
+        except Exception as e:
+            raise RuntimeError(e) from e
+
+        print(f"[batch {batch_mode}] complete")  # noqa: T201

python/tests/onnx_quantizer_tests/layers/base.py

@@ -98,7 +98,7 @@ class LayerTestConfig:
         combined_inits = {**self.required_initializers, **initializer_overrides}
         for name, data in combined_inits.items():
             # Special handling for shape tensors in Reshape, etc.
-            if name == "shape":
+            if name in {"shape", "axes"}:
                 tensor = numpy_helper.from_array(data.astype(np.int64), name=name)
             else:
                 tensor = numpy_helper.from_array(data.astype(np.float32), name=name)

python/tests/onnx_quantizer_tests/layers/squeeze_config.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import numpy as np
+
+from python.core.model_processing.onnx_quantizer.exceptions import InvalidParamError
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    error_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class SqueezeConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for Squeeze"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Squeeze"
+
+    def get_config(self) -> LayerTestConfig:
+        # Test opset-newer form: Squeeze(data, axes) where axes is an int64 initializer.
+        return LayerTestConfig(
+            op_type="Squeeze",
+            valid_inputs=["A", "axes"],
+            valid_attributes={},  # no attribute-based axes
+            required_initializers={},
+            input_shapes={
+                "A": [1, 3, 1, 5],
+                # "axes" is removed from graph inputs automatically
+                # when it is an initializer.
+                "axes": [2],
+            },
+            output_shapes={
+                "squeeze_output": [3, 5],
+            },
+        )
+
+    def get_test_specs(self) -> list:
+
+        return [
+            # --- VALID TESTS ---
+            valid_test("axes_omitted")
+            .description("Squeeze with no axes input: removes all dims of size 1")
+            .override_inputs("A")  # only data input
+            .override_input_shapes(A=[1, 3, 1, 5])
+            .override_output_shapes(squeeze_output=[3, 5])
+            .tags("basic", "squeeze", "axes_omitted")
+            .build(),
+            valid_test("axes_init_basic")
+            .description("Squeeze with axes initializer [0,2] on [1,3,1,5] -> [3,5]")
+            .override_inputs("A", "axes")
+            .override_initializer("axes", np.array([0, 2], dtype=np.int64))
+            .override_input_shapes(A=[1, 3, 1, 5])
+            .override_output_shapes(squeeze_output=[3, 5])
+            .tags("basic", "squeeze", "axes_initializer")
+            .build(),
+            valid_test("axes_init_singleton_middle")
+            .description("Squeeze with axes initializer [1] on [2,1,4] -> [2,4]")
+            .override_inputs("A", "axes")
+            .override_initializer("axes", np.array([1], dtype=np.int64))
+            .override_input_shapes(A=[2, 1, 4])
+            .override_output_shapes(squeeze_output=[2, 4])
+            .tags("squeeze", "axes_initializer")
+            .build(),
+            valid_test("axes_init_negative")
+            .description("Squeeze with axes initializer [-2] on [2,1,4] -> [2,4]")
+            .override_inputs("A", "axes")
+            .override_initializer("axes", np.array([-2], dtype=np.int64))
+            .override_input_shapes(A=[2, 1, 4])
+            .override_output_shapes(squeeze_output=[2, 4])
+            .tags("squeeze", "axes_initializer", "negative_axis")
+            .build(),
+            # --- ERROR TESTS ---
+            error_test("duplicate_axes_init")
+            .description("Duplicate axes in initializer should be rejected")
+            .override_inputs("A", "axes")
+            .override_initializer("axes", np.array([1, 1], dtype=np.int64))
+            .override_input_shapes(A=[2, 1, 4])
+            .override_output_shapes(squeeze_output=[2, 4])
+            .expects_error(InvalidParamError, match="axes must not contain duplicates")
+            .tags("error", "squeeze", "axes_initializer")
+            .build(),
+            error_test("dynamic_axes_input_not_supported")
+            .description(
+                "Squeeze with runtime axes (2 inputs but axes is NOT an initializer) "
+                "should be rejected",
+            )
+            .override_inputs("A", "axes")  # axes provided as graph input (unsupported)
+            .override_input_shapes(A=[1, 3, 1, 5], axes=[2])
+            .override_output_shapes(squeeze_output=[3, 5])
+            .expects_error(
+                InvalidParamError,
+                match="Dynamic axes input is not supported",
+            )
+            .tags("error", "squeeze", "axes_input")
+            .build(),
+            # --- E2E TESTS ---
+            e2e_test("e2e_axes_omitted")
+            .description("End-to-end Squeeze test (axes omitted)")
+            .override_inputs("A")
+            .override_input_shapes(A=[1, 3, 1, 5])
+            .override_output_shapes(squeeze_output=[3, 5])
+            .tags("e2e", "squeeze")
+            .build(),
+            e2e_test("e2e_axes_init")
+            .description("End-to-end Squeeze test (axes initializer)")
+            .override_inputs("A", "axes")
+            .override_initializer("axes", np.array([0, 2], dtype=np.int64))
+            .override_input_shapes(A=[1, 3, 1, 5])
+            .override_output_shapes(squeeze_output=[3, 5])
+            .tags("e2e", "squeeze", "axes_initializer")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/unsqueeze_config.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import numpy as np
+
+from python.core.model_processing.onnx_quantizer.exceptions import InvalidParamError
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    error_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class UnsqueezeConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for Unsqueeze"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Unsqueeze"
+
+    def get_config(self) -> LayerTestConfig:
+        # Test opset-newer form: Unsqueeze(data, axes)
+        # where axes is an int64 initializer.
+        return LayerTestConfig(
+            op_type="Unsqueeze",
+            valid_inputs=["A", "axes"],
+            valid_attributes={},  # no attribute-based axes
+            required_initializers={},
+            input_shapes={
+                "A": [3, 5],
+                # "axes" will be removed from graph inputs automatically
+                # when it is an initializer.
+                "axes": [2],
+            },
+            output_shapes={
+                "unsqueeze_output": [1, 3, 1, 5],
+            },
+        )
+
+    def get_test_specs(self) -> list:
+
+        return [
+            # --- VALID TESTS ---
+            valid_test("axes_init_basic")
+            .description("Unsqueeze with axes initializer [0,2] on [3,5] -> [1,3,1,5]")
+            .override_inputs("A", "axes")
+            .override_initializer("axes", np.array([0, 2], dtype=np.int64))
+            .override_input_shapes(A=[3, 5])
+            .override_output_shapes(unsqueeze_output=[1, 3, 1, 5])
+            .tags("basic", "unsqueeze", "axes_initializer")
+            .build(),
+            valid_test("axes_init_single_axis")
+            .description("Unsqueeze with axes initializer [1] on [3,5] -> [3,1,5]")
+            .override_inputs("A", "axes")
+            .override_initializer("axes", np.array([1], dtype=np.int64))
+            .override_input_shapes(A=[3, 5])
+            .override_output_shapes(unsqueeze_output=[3, 1, 5])
+            .tags("unsqueeze", "axes_initializer")
+            .build(),
+            valid_test("axes_init_negative")
+            .description("Unsqueeze with negative axis [-1] on [3,5] -> [3,5,1]")
+            .override_inputs("A", "axes")
+            .override_initializer("axes", np.array([-1], dtype=np.int64))
+            .override_input_shapes(A=[3, 5])
+            .override_output_shapes(unsqueeze_output=[3, 5, 1])
+            .tags("unsqueeze", "axes_initializer", "negative_axis")
+            .build(),
+            valid_test("axes_init_two_axes_append")
+            .description("Unsqueeze with axes [2,3] on [3,5] -> [3,5,1,1]")
+            .override_inputs("A", "axes")
+            .override_initializer("axes", np.array([2, 3], dtype=np.int64))
+            .override_input_shapes(A=[3, 5])
+            .override_output_shapes(unsqueeze_output=[3, 5, 1, 1])
+            .tags("unsqueeze", "axes_initializer")
+            .build(),
+            # --- ERROR TESTS ---
+            error_test("duplicate_axes_init")
+            .description("Duplicate axes in initializer should be rejected")
+            .override_inputs("A", "axes")
+            .override_initializer("axes", np.array([1, 1], dtype=np.int64))
+            .override_input_shapes(A=[3, 5])
+            .override_output_shapes(
+                unsqueeze_output=[3, 1, 5],
+            )  # not used; kept consistent
+            .expects_error(InvalidParamError, match="axes must not contain duplicates")
+            .tags("error", "unsqueeze", "axes_initializer")
+            .build(),
+            error_test("dynamic_axes_input_not_supported")
+            .description(
+                "Unsqueeze with runtime axes (2 inputs but axes is NOT an initializer) "
+                "should be rejected",
+            )
+            .override_inputs("A", "axes")  # axes provided as graph input (unsupported)
+            .override_input_shapes(A=[3, 5], axes=[2])
+            .override_output_shapes(unsqueeze_output=[1, 3, 1, 5])
+            .expects_error(
+                InvalidParamError,
+                match="Dynamic axes input is not supported",
+            )
+            .tags("error", "unsqueeze", "axes_input")
+            .build(),
+            # --- E2E TESTS ---
+            e2e_test("e2e_axes_init")
+            .description("End-to-end Unsqueeze test (axes initializer)")
+            .override_inputs("A", "axes")
+            .override_initializer("axes", np.array([0, 2], dtype=np.int64))
+            .override_input_shapes(A=[3, 5])
+            .override_output_shapes(unsqueeze_output=[1, 3, 1, 5])
+            .tags("e2e", "unsqueeze", "axes_initializer")
+            .build(),
+        ]

python/tests/test_cli.py

@@ -1019,3 +1019,186 @@ def test_bench_with_iterations(tmp_path: Path) -> None:
     assert "--iterations" in cmd
     idx = cmd.index("--iterations")
     assert cmd[idx + 1] == "10"
+
+
+@pytest.mark.unit
+def test_batch_prove_dispatch(tmp_path: Path) -> None:
+    circuit = tmp_path / "circuit.txt"
+    circuit.write_text("ok")
+
+    manifest = tmp_path / "manifest.json"
+    manifest.write_text('{"jobs": []}')
+
+    metadata = tmp_path / "circuit_metadata.json"
+    metadata.write_text("{}")
+
+    fake_circuit = MagicMock()
+    fake_circuit.name = "test_circuit"
+
+    with (
+        patch(
+            "python.frontend.commands.batch.BatchCommand._build_circuit",
+            return_value=fake_circuit,
+        ),
+        patch(
+            "python.frontend.commands.batch.run_cargo_command",
+        ) as mock_cargo,
+    ):
+        rc = main(
+            [
+                "--no-banner",
+                "batch",
+                "prove",
+                "-c",
+                str(circuit),
+                "-f",
+                str(manifest),
+            ],
+        )
+
+    assert rc == 0
+    mock_cargo.assert_called_once()
+    call_kwargs = mock_cargo.call_args[1]
+    assert call_kwargs["command_type"] == "run_batch_prove"
+    assert call_kwargs["args"]["c"] == str(circuit)
+    assert call_kwargs["args"]["f"] == str(manifest)
+
+
+@pytest.mark.unit
+def test_batch_verify_dispatch(tmp_path: Path) -> None:
+    circuit = tmp_path / "circuit.txt"
+    circuit.write_text("ok")
+
+    manifest = tmp_path / "manifest.json"
+    manifest.write_text('{"jobs": []}')
+
+    metadata = tmp_path / "circuit_metadata.json"
+    metadata.write_text("{}")
+
+    processed = tmp_path / "manifest_processed.json"
+    processed.write_text('{"jobs": []}')
+
+    fake_circuit = MagicMock()
+    fake_circuit.name = "test_circuit"
+
+    with (
+        patch(
+            "python.frontend.commands.batch.BatchCommand._build_circuit",
+            return_value=fake_circuit,
+        ),
+        patch(
+            "python.frontend.commands.batch._preprocess_manifest",
+            return_value=str(processed),
+        ) as mock_preprocess,
+        patch(
+            "python.frontend.commands.batch.run_cargo_command",
+        ) as mock_cargo,
+    ):
+        rc = main(
+            [
+                "--no-banner",
+                "batch",
+                "verify",
+                "-c",
+                str(circuit),
+                "-f",
+                str(manifest),
+            ],
+        )
+
+    assert rc == 0
+    mock_preprocess.assert_called_once()
+    mock_cargo.assert_called_once()
+    call_kwargs = mock_cargo.call_args[1]
+    assert call_kwargs["command_type"] == "run_batch_verify"
+    assert call_kwargs["args"]["f"] == str(processed)
+
+
+@pytest.mark.unit
+def test_batch_witness_dispatch(tmp_path: Path) -> None:
+    circuit = tmp_path / "circuit.txt"
+    circuit.write_text("ok")
+
+    manifest = tmp_path / "manifest.json"
+    manifest.write_text('{"jobs": []}')
+
+    metadata = tmp_path / "circuit_metadata.json"
+    metadata.write_text("{}")
+
+    processed = tmp_path / "manifest_processed.json"
+    processed.write_text('{"jobs": []}')
+
+    fake_circuit = MagicMock()
+    fake_circuit.name = "test_circuit"
+
+    with (
+        patch(
+            "python.frontend.commands.batch.BatchCommand._build_circuit",
+            return_value=fake_circuit,
+        ),
+        patch(
+            "python.frontend.commands.batch._preprocess_manifest",
+            return_value=str(processed),
+        ) as mock_preprocess,
+        patch(
+            "python.frontend.commands.batch.run_cargo_command",
+        ) as mock_cargo,
+    ):
+        rc = main(
+            [
+                "--no-banner",
+                "batch",
+                "witness",
+                "-c",
+                str(circuit),
+                "-f",
+                str(manifest),
+            ],
+        )
+
+    assert rc == 0
+    mock_preprocess.assert_called_once()
+    mock_cargo.assert_called_once()
+    call_kwargs = mock_cargo.call_args[1]
+    assert call_kwargs["command_type"] == "run_batch_witness"
+    assert call_kwargs["args"]["f"] == str(processed)
+
+
+@pytest.mark.unit
+def test_batch_missing_circuit(tmp_path: Path) -> None:
+    manifest = tmp_path / "manifest.json"
+    manifest.write_text('{"jobs": []}')
+
+    rc = main(
+        [
+            "--no-banner",
+            "batch",
+            "prove",
+            "-c",
+            str(tmp_path / "nonexistent.txt"),
+            "-f",
+            str(manifest),
+        ],
+    )
+
+    assert rc == 1
+
+
+@pytest.mark.unit
+def test_batch_missing_manifest(tmp_path: Path) -> None:
+    circuit = tmp_path / "circuit.txt"
+    circuit.write_text("ok")
+
+    rc = main(
+        [
+            "--no-banner",
+            "batch",
+            "prove",
+            "-c",
+            str(circuit),
+            "-f",
+            str(tmp_path / "nonexistent.json"),
+        ],
+    )
+
+    assert rc == 1