parityos-cudaq 0.1.0__tar.gz

parityos_cudaq-0.1.0/.gitignore

@@ -0,0 +1,96 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+coverage.xml
+report.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Sphinx documentation
+**/docs/_build/
+**/docs/**/generated/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery
+celerybeat-schedule
+celerybeat.pid
+
+# Environments
+*.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+uv.lock
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDE stuff
+*.iws
+*.iml
+**/.idea/
+**/.idea/**
+**/.vscode
+
+# Apple stuff
+.DS_Store
+
+# artifacts
+.png
+.tar
+
+# uv
+uv.toml
+

parityos_cudaq-0.1.0/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+
+## [0.1.0] - 2026-06-10
+
+### Added
+
+ - Separate packages for each exporter (#132)

parityos_cudaq-0.1.0/LICENSE.txt

@@ -0,0 +1,37 @@
+ParityOS Client Software License Terms (BSD-3-Clause)
+=====================================================
+
+Copyright 2023 Parity Quantum Computing GmbH (ParityQC)
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+===============================================================================
+
+Parity Quantum Computing GmbH
+Rennweg 1 / Top 314 / 6020 Innsbruck, Austria
+info@parityqc.com / www.parityqc.com
+
+===============================================================================

parityos_cudaq-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: parityos-cudaq
+Version: 0.1.0
+Summary: CudaQ extension for ParityOS
+Project-URL: Homepage, https://parityqc.com/
+Author-email: ParityQC <parityos@parityqc.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE.txt
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: attrs
+Requires-Dist: parityos>=3.0.0
+Description-Content-Type: text/markdown
+
+# ParityOS CudaQ
+
+ParityOS extension adding an interface to [cudaq](https://developer.nvidia.com/cuda-q).
+
+## Installation
+
+It is recommended to install this package in a separate Python virtual environment. For example:
+
+```shell
+# To create a standard Python virtual environment:
+python -m venv my_new_venv && source my_new_venv/bin/activate
+# Alternatively, to create a Anaconda/Miniconda environment:
+conda create --name my_new_conda_env python=<version> && conda activate my_new_conda_env
+# or a pyenv environment
+pyenv virtualenv <version> my_new_venv && pyenv activate my_new_venv
+# or a uv managed environment
+uv venv -p <version>
+```
+where `<version>` is a python version and one of `[3.11, 3.12, 3.13]`.
+
+After activating the virtual environment, install via your favorite package manager, e.g.:
+
+```shell
+# using pip
+pip install parityos-cudaq
+# using uv
+uv pip install parityos-cudaq
+```
+
+## Exporter
+
+`parityos-cudaq` offers an exporter of ParityOS to quantum circuits to the 
+[Quake dialect](https://nvidia.github.io/cuda-quantum/latest/specification/quake-dialect.html) .
+
+```python
+from parityos.bits import get_q
+from parityos.operators.circuit import Circuit
+from parityos.operators.controlled_operator import CNOT
+from parityos.operators.elementary_operator import H, Z
+from parityos.operators.rotation_operator import RX
+from parityos_cudaq.exporter import export_parityos_to_quake
+
+# Create circuit qubits.
+qubits = [get_q(name) for name in ("a", "b", "c")]
+
+# Create the following circuit as sequence of gates, followed by a measurement of all qubits.
+#     ┌───────┐┌───┐┌───┐   ┌─┐
+# qa: ┤ Rx(2) ├┤ H ├┤ Z ├───┤M├
+#     └───────┘├───┤└┬─┬┘   └╥┘
+# qb: ─────────┤ X ├─┤M├─────╫─
+#       ┌───┐  └─┬─┘ └╥┘ ┌─┐ ║ 
+# qc: ──┤ H ├────■────╫──┤M├─╫─
+#       └───┘         ║  └╥┘ ║ 
+# c: 3/═══════════════╩═══╩══╩═
+#                     1   2  0 
+circuit = Circuit(
+    [
+        RX(qubits[0], 2),
+        H(qubits[0]),
+        H(qubits[2]),
+        CNOT(qubits[2], qubits[1]),
+        Z(qubits[0]),
+    ]
+).measure_all()
+
+# Export to quake. 
+qiskit_result = export_parityos_to_quake(circuit, False)
+
+print(qiskit_result.module)
+# // Generated by ParityOS
+# module {
+#   func.func @parityos_circuit() {
+#     // Allocate register
+#     %n_qubits = arith.constant 3 : i64
+#     %register = quake.alloca !quake.veq<?>[%n_qubits : i64]
+#     %q_0 = quake.extract_ref %register[0] : (!quake.veq<?>) -> !quake.ref
+#     %q_1 = quake.extract_ref %register[1] : (!quake.veq<?>) -> !quake.ref
+#     %q_2 = quake.extract_ref %register[2] : (!quake.veq<?>) -> !quake.ref
+#    
+#     %angle_0 = arith.constant 2.0 : f64
+#     quake.rx (%angle_0) %q_0 : (f64, !quake.ref) -> ()
+#     quake.h %q_0 : (!quake.ref) -> ()
+#     quake.h %q_2 : (!quake.ref) -> ()
+#     quake.x [%q_2] %q_1 : (!quake.ref, !quake.ref) -> ()
+#     quake.z %q_0 : (!quake.ref) -> ()
+#     %m_result_0 = quake.mz %q_0 : (!quake.ref) -> !quake.measure
+#    
+#     %m_result_1 = quake.mz %q_1 : (!quake.ref) -> !quake.measure
+#    
+#     %m_result_2 = quake.mz %q_2 : (!quake.ref) -> !quake.measure
+#    
+#     return
+#   }
+# }
+
+print(qiskit_result.qubit_map)  # Maps ParityOS qubits to quake Qubit integer labels
+# {Qubit(id='a'): 0, Qubit(id='b'): 1, Qubit(id='c'): 2}
+```
+
+## License
+
+This software package is made available under the 3-Clause BSD License. 
+See `License.txt` for details.

parityos_cudaq-0.1.0/README.md

@@ -0,0 +1,103 @@
+# ParityOS CudaQ
+
+ParityOS extension adding an interface to [cudaq](https://developer.nvidia.com/cuda-q).
+
+## Installation
+
+It is recommended to install this package in a separate Python virtual environment. For example:
+
+```shell
+# To create a standard Python virtual environment:
+python -m venv my_new_venv && source my_new_venv/bin/activate
+# Alternatively, to create a Anaconda/Miniconda environment:
+conda create --name my_new_conda_env python=<version> && conda activate my_new_conda_env
+# or a pyenv environment
+pyenv virtualenv <version> my_new_venv && pyenv activate my_new_venv
+# or a uv managed environment
+uv venv -p <version>
+```
+where `<version>` is a python version and one of `[3.11, 3.12, 3.13]`.
+
+After activating the virtual environment, install via your favorite package manager, e.g.:
+
+```shell
+# using pip
+pip install parityos-cudaq
+# using uv
+uv pip install parityos-cudaq
+```
+
+## Exporter
+
+`parityos-cudaq` offers an exporter of ParityOS to quantum circuits to the 
+[Quake dialect](https://nvidia.github.io/cuda-quantum/latest/specification/quake-dialect.html) .
+
+```python
+from parityos.bits import get_q
+from parityos.operators.circuit import Circuit
+from parityos.operators.controlled_operator import CNOT
+from parityos.operators.elementary_operator import H, Z
+from parityos.operators.rotation_operator import RX
+from parityos_cudaq.exporter import export_parityos_to_quake
+
+# Create circuit qubits.
+qubits = [get_q(name) for name in ("a", "b", "c")]
+
+# Create the following circuit as sequence of gates, followed by a measurement of all qubits.
+#     ┌───────┐┌───┐┌───┐   ┌─┐
+# qa: ┤ Rx(2) ├┤ H ├┤ Z ├───┤M├
+#     └───────┘├───┤└┬─┬┘   └╥┘
+# qb: ─────────┤ X ├─┤M├─────╫─
+#       ┌───┐  └─┬─┘ └╥┘ ┌─┐ ║ 
+# qc: ──┤ H ├────■────╫──┤M├─╫─
+#       └───┘         ║  └╥┘ ║ 
+# c: 3/═══════════════╩═══╩══╩═
+#                     1   2  0 
+circuit = Circuit(
+    [
+        RX(qubits[0], 2),
+        H(qubits[0]),
+        H(qubits[2]),
+        CNOT(qubits[2], qubits[1]),
+        Z(qubits[0]),
+    ]
+).measure_all()
+
+# Export to quake. 
+qiskit_result = export_parityos_to_quake(circuit, False)
+
+print(qiskit_result.module)
+# // Generated by ParityOS
+# module {
+#   func.func @parityos_circuit() {
+#     // Allocate register
+#     %n_qubits = arith.constant 3 : i64
+#     %register = quake.alloca !quake.veq<?>[%n_qubits : i64]
+#     %q_0 = quake.extract_ref %register[0] : (!quake.veq<?>) -> !quake.ref
+#     %q_1 = quake.extract_ref %register[1] : (!quake.veq<?>) -> !quake.ref
+#     %q_2 = quake.extract_ref %register[2] : (!quake.veq<?>) -> !quake.ref
+#    
+#     %angle_0 = arith.constant 2.0 : f64
+#     quake.rx (%angle_0) %q_0 : (f64, !quake.ref) -> ()
+#     quake.h %q_0 : (!quake.ref) -> ()
+#     quake.h %q_2 : (!quake.ref) -> ()
+#     quake.x [%q_2] %q_1 : (!quake.ref, !quake.ref) -> ()
+#     quake.z %q_0 : (!quake.ref) -> ()
+#     %m_result_0 = quake.mz %q_0 : (!quake.ref) -> !quake.measure
+#    
+#     %m_result_1 = quake.mz %q_1 : (!quake.ref) -> !quake.measure
+#    
+#     %m_result_2 = quake.mz %q_2 : (!quake.ref) -> !quake.measure
+#    
+#     return
+#   }
+# }
+
+print(qiskit_result.qubit_map)  # Maps ParityOS qubits to quake Qubit integer labels
+# {Qubit(id='a'): 0, Qubit(id='b'): 1, Qubit(id='c'): 2}
+```
+
+## License
+
+This software package is made available under the 3-Clause BSD License. 
+See `License.txt` for details.

parityos_cudaq-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "parityos-cudaq"
+dynamic = ["version"]
+description = "CudaQ extension for ParityOS"
+readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICENSE.txt"]
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+
+dependencies = [
+    "attrs",
+    "parityos>=3.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "filecheck",
+    "cudaq",
+]
+
+[[project.authors]]
+name = "ParityQC"
+email = "parityos@parityqc.com"
+
+[project.urls]
+Homepage = "https://parityqc.com/"
+
+[tool.hatch.version]
+path = "src/parityos_cudaq/_version.py"

parityos_cudaq-0.1.0/src/parityos_cudaq/__init__.py

@@ -0,0 +1,3 @@
+from ._version import __version__
+
+__all__ = ["__version__"]

parityos_cudaq-0.1.0/src/parityos_cudaq/_version.py

@@ -0,0 +1,3 @@
+# This file is automatically managed by hatch, do not edit manually.
+
+__version__ = "0.1.0"

parityos_cudaq-0.1.0/src/parityos_cudaq/exporter.py

@@ -0,0 +1,366 @@
+"""Exporter for translating ParityOS circuits to the Nvidia CUDA-Q Quake MLIR dialect."""
+# ParityQC © 2020-2026. See the LICENSE file in the top level directory for details.
+
+from __future__ import annotations
+
+from types import MappingProxyType
+from typing import Generic, final
+
+from attrs import frozen
+from parityos.bits import Qubit, QubitT
+from parityos.operators.circuit import CircuitLike
+from parityos.operators.conditional_operator import ConditionalOperator
+from parityos.operators.controlled_operator import ControlledOperator
+from parityos.operators.measurement import MX, MZ, Measurement, Reset
+from parityos.operators.operator import Operator
+from parityos.operators.pauli_basis import XBasis, ZBasis
+from parityos.operators.rotation_operator import HasAngle
+from parityos.utils.exceptions import ParityOSNotSupportedError
+
+
+@frozen
+class QuakeExportResult:
+    """Result of exporting a ParityOS circuit to a Quake IR program.
+
+    The exported module will extract qubit reference like this:
+    ```
+    %q_0 = quake.extract_ref %register[0] : (!quake.veq<?>) -> !quake.ref
+    ^^^^                               ^
+    insignificant variable name        meaningful register index
+    ```
+    """
+
+    #: Exported Quake program.
+    module: str
+    #: Mapping from parityos qubits to their indices in the quake register.
+    qubit_map: dict[Qubit, int]
+
+
+def export_parityos_to_quake(
+    parityos_circuit: CircuitLike[Qubit], emulate_nvqpp: bool
+) -> QuakeExportResult:
+    """Export a ParityOS circuit to Quake.
+
+    If the circuit name is a legal name (contains only alphanumerics and underscores, but does not
+    start with a numeric), the ``func.func`` is given the circuit name as symbol name, prefixed with
+    "@". Otherwise, the ``func.func`` symbol name defaults to ``@parityos_circuit``.
+
+    Example:
+        Bell state circuit:
+        ```
+        module {
+            func.func @parityos_circuit() {
+                // Allocate register
+                %n_qubits = arith.constant 2 : i64
+                %register = quake.alloca !quake.veq<?>[%n_qubits : i64]
+                %q_0 = quake.extract_ref %register[0] : (!quake.veq<?>) -> !quake.ref
+                %q_1 = quake.extract_ref %register[1] : (!quake.veq<?>) -> !quake.ref
+
+                quake.h %q_0 : (!quake.ref) -> ()
+                quake.x [%q_0] %q_1 : (!quake.ref, !quake.ref) -> ()
+
+                %m_result_0 = quake.mz %q_0 : (!quake.ref) -> !quake.measure
+                %m_result_1 = quake.mz %q_1 : (!quake.ref) -> !quake.measure
+            }
+        }
+        ```
+
+    Args:
+        parityos_circuit: Circuit to be exported.
+        emulate_nvqpp: Emulate the output of the nvqpp compiler from CUDA-Q.
+            Enabling this adds some attributes to the output module and function.
+            TODO: We do not know yet whether this will be needed in any context.
+            May be removed in the future.
+    """
+    exporter = _QuakeExporter(emulate_nvqpp)
+    exporter.export(parityos_circuit)
+
+    return QuakeExportResult(
+        module=exporter.module,
+        qubit_map=exporter.qubit_map,
+    )
+
+
+@final
+class _QuakeExporter(Generic[QubitT]):
+    """Exports a ParityOS circuit to the Cuda-Q Quake IR."""
+
+    # a map between ParityOS to Quake operations names
+    _PARITY_OS_TO_QUAKE = MappingProxyType(
+        {
+            # 1 target, 0 params:
+            "x": "x",
+            "y": "y",
+            "z": "z",
+            "h": "h",
+            "s": "s",
+            "sdg": "s<adj>",
+            "t": "t",
+            "tdg": "t<adj>",
+            # 1 target, 1 param:
+            "rx": "rx",
+            "ry": "ry",
+            "rz": "rz",
+            # 2 targets, 0 params
+            "swap": "swap",
+        }
+    )
+
+    @staticmethod
+    def _lookup_quake_name(parityos_name: str) -> str:
+        """Look up the corresponding Quake operator name for a
+        given parityos gate.
+
+        Args:
+            parityos_name: Name of the ParityOS gate to translate into Quake.
+
+        Returns:
+            A string containing the name of the corresponding Quake gate.
+
+        Raises:
+            ParityOSNotSupportedError: When the gate is not supported for export.
+        """
+        if parityos_name not in _QuakeExporter._PARITY_OS_TO_QUAKE:
+            raise ParityOSNotSupportedError(f"Gate {parityos_name} not supported for Quake export")
+
+        return _QuakeExporter._PARITY_OS_TO_QUAKE[parityos_name]
+
+    def __init__(self, emulate_nvqpp: bool) -> None:
+        """Create a new Quake Exporter object.
+
+        Args:
+            emulate_nvqpp: Emulate the output of the nvqpp compiler from CUDA-Q.
+                Enabling this adds some attributes to the output module and function.
+        """
+        self._module: str = ""
+        self._qubit_map: dict[QubitT, str] = dict()
+        self._qubit_index_map: dict[QubitT, int] = dict()
+        self._emulate_nvqpp = emulate_nvqpp
+        self._indentation = " " * 4
+        self._angle_count = 0
+        self._measurement_count = 0
+
+    @property
+    def module(self) -> str:
+        return self._module
+
+    @property
+    def qubit_map(self) -> dict[QubitT, int]:
+        """Mapping of ParityOS Qubit to Quake register index."""
+        return self._qubit_index_map
+
+    def export(self, circuit: CircuitLike[QubitT]) -> None:
+        """Export ParityOS Circuit to a Quake program.
+
+        Should only be called once.
+
+        Args:
+            circuit: ParityOS Circuit to be exported to Quake.
+
+        Returns:
+            Translated Quake program.
+        """
+        self._add_header(circuit)
+
+        self._add_allocation(circuit)
+
+        for op in circuit.operators:
+            self._add_operator(op)
+
+        self._add_termination()
+
+    @staticmethod
+    def _is_legal_circuit_name(name: str):
+        """Checks if a circuit name is a valid alphanumeric identifier.
+
+        A valid identifier must be non-empty, must not start with a digit,
+        and can only contain alphanumeric characters or underscores.
+
+        Args:
+            name: A circuit name to be validated.
+
+        Returns:
+            ``True`` if the name is a valid identifier, ``False`` otherwise.
+        """
+        return (
+            len(name) > 0 and not name[0].isnumeric() and all(c.isalnum() or c in "_" for c in name)
+        )
+
+    def _add_header(self, circuit: CircuitLike[Qubit]):
+        """Add the correct header string to the current conversion output.
+
+        Args:
+            circuit: The circuit to be exported.
+        """
+        circuit_name = (
+            circuit.name if self._is_legal_circuit_name(circuit.name) else "parityos_circuit"
+        )
+
+        if self._emulate_nvqpp:
+            funcfunc_name = f"__nvqpp__mlirgen__{circuit_name}"
+            # The C++ name mangling is to be read as follows:
+            # "_ZN" indicates a C++ function.
+            # Next comes the function namespace and name. To know where the namespace ends and
+            # where the name begins, the string is prefixed by the length of the namespace.
+            # Here, by cuda-q convention, the namespace is the circuit name, and the function name
+            # is "cl".
+            # The last two characters indicate void return type ("E") and void arguments ("v").
+            circuit_name_mangled = f"_ZN{len(circuit_name)}{circuit_name}clEv"
+            self._module = (
+                "// Generated by ParityOS\n"
+                + f'module attributes {{qtx.mangled_name_map = {{{funcfunc_name} = "{circuit_name_mangled}"}}}} {{\n'
+                + f'  func.func @{funcfunc_name}() attributes {{"cudaq-entrypoint", "cudaq-kernel"}} {{\n'
+            )
+        else:
+            funcfunc_name = f"{circuit_name}"
+            self._module = (
+                "// Generated by ParityOS\n" + "module {\n" + f"  func.func @{funcfunc_name}() {{\n"
+            )
+
+    def _add_termination(self):
+        """Add a return statement to the current conversion output."""
+        self._add_line("return")
+        self._module += "  }\n}\n"
+
+    def _add_line(self, text: str):
+        """Add one line to the current conversion output."""
+        self._module += f"{self._indentation}{text}\n"
+
+    def _add_comment(self, comment: str):
+        """Add a comment to the current conversion output."""
+        self._add_line(f"// {comment}")
+
+    def _add_allocation(self, circuit: CircuitLike[QubitT]) -> None:
+        """Allocate the qubits required for the circuit using Quake dialect."""
+        qubits = circuit.ordered_qubits
+        self._add_comment("Allocate register")
+        self._add_line(f"%n_qubits = arith.constant {len(qubits)} : i64")
+        self._add_line("%register = quake.alloca !quake.veq<?>[%n_qubits : i64]")
+
+        for index, qubit in enumerate(qubits):
+            self._qubit_map[qubit] = f"%q_{index}"
+            self._qubit_index_map[qubit] = index
+            self._add_line(
+                f"%q_{index} = quake.extract_ref %register[{index}] : (!quake.veq<?>) -> !quake.ref"
+            )
+
+        self._add_line("")
+
+    def _add_operator(self, operator: Operator[QubitT]) -> None:
+        """Convert an operator to the Quake dialect.
+
+        Raises:
+            ParityOSNotSupportedError: When the operator is a conditional one.
+        """
+        if isinstance(operator, ConditionalOperator):
+            raise ParityOSNotSupportedError("Conditional Operator not supported.")
+
+        if isinstance(operator, Measurement):
+            self._add_measurement(operator)
+            return
+
+        if isinstance(operator, Reset):
+            self._add_reset(operator)
+            return
+
+        controlled_qubits: tuple[QubitT, ...] | None
+        target_qubits: tuple[QubitT, ...]
+        quake_operation_name: str
+
+        if isinstance(operator, ControlledOperator):
+            controlled_qubits = tuple(sorted(operator.control_qubits))
+            target_qubits = operator.ordered_target_qubits
+            quake_operation_name = self._lookup_quake_name(operator.target_operator.name)
+        else:
+            controlled_qubits = None
+            target_qubits = operator.ordered_qubits
+            quake_operation_name = self._lookup_quake_name(operator.name)
+        angle = _extract_gate_angle(operator)
+        angle_var = None
+        n_qubits = len(operator.qubits)
+
+        # Code generation
+        if angle is not None:
+            angle_var = self._new_angle_var()
+            self._add_line(f"{angle_var} = arith.constant {angle} : f64")
+        self._add_line(
+            f"quake.{quake_operation_name} "
+            + (f"({angle_var}) " if angle is not None else "")
+            + (
+                f"[{', '.join([self._qubit_map[q] for q in controlled_qubits])}] "
+                if controlled_qubits is not None
+                else ""
+            )
+            + f"{', '.join([self._qubit_map[q] for q in target_qubits])} : ("
+            + ("f64, " if angle is not None else "")
+            + ", ".join(["!quake.ref"] * n_qubits)
+            + ") -> ()"
+        )
+
+    def _new_angle_var(self) -> str:
+        """Generate a unique angle variable name, including % prefix."""
+        angle_var = f"%angle_{self._angle_count}"
+        self._angle_count += 1
+        return angle_var
+
+    def _new_measurement_var(self) -> str:
+        """Generate a unique measurement result variable name, including % prefix."""
+        measurement_var = f"%m_result_{self._measurement_count}"
+        self._measurement_count += 1
+        return measurement_var
+
+    def _add_measurement(self, measure: Measurement[QubitT, XBasis | ZBasis]) -> None:
+        """Convert a measurement operatin to the Quake dialect.
+
+        Args:
+            measure: the qubits to be measured and the basis they should be measured on
+
+        Raises:
+            ParityOSNotSupportedError: If a partial measurement is triggered or in a basis different
+                from X or Z.
+        """
+        if len(measure.qubits) == 1:
+            target = self._qubit_map[measure.qubit]
+            source_type = "!quake.ref"
+            target_type = "!quake.measure"
+        elif len(measure.qubits) != len(self._qubit_map):
+            target = "%register"
+            source_type = "!quake.veq<?>"
+            target_type = "!cc.stdvec<!quake.measure>"
+        else:
+            raise ParityOSNotSupportedError(
+                "Only measurement of single qubits or the entire register is supported."
+            )
+
+        if isinstance(measure, MX):
+            op_name = "mx"
+        elif isinstance(measure, MZ):
+            op_name = "mz"
+        else:
+            raise ParityOSNotSupportedError(f"Unsupported measurement '{measure.name}'.")
+
+        self._add_line(
+            f"{self._new_measurement_var()} = "
+            + f"quake.{op_name} {target} : ({source_type}) -> {target_type}"
+        )
+        self._add_line("")
+
+    def _add_reset(self, reset: Reset[QubitT]):
+        """Convert a set of reset operatin to the Quake dialect."""
+        for qubit in reset.ordered_qubits:
+            self._add_line(f"quake.reset {self._qubit_map[qubit]} : (!quake.ref) -> ()")
+
+
+def _extract_gate_angle(operator: Operator[QubitT]) -> float | None:
+    """Extract the angle of a rotation gate, or return `None` if no angle exists.
+
+    Raises:
+        ParityOSNotSupportedError: If the angle is not an integer or float.
+    """
+    if not isinstance(operator, HasAngle):  # noqa: SIM108
+        return None
+
+    if not isinstance(operator.angle, float | int):
+        raise ParityOSNotSupportedError("Symbolic parameters not supported.")
+
+    return float(operator.angle)

parityos_cudaq-0.1.0/test_parityos_cudaq/quake_circuits.py

@@ -0,0 +1,294 @@
+"""This file contains the quake circuit equivalent of the ParityOS circuits defined in
+parityos_circuits.py, given in FILECHECK match syntax.
+
+In addition, a few more ParityOS test circuits are defined.
+"""
+# ParityQC © 2025. See the LICENSE file in the top level directory for details.
+
+from parityos.bits import Qubit
+from parityos.bits import get_q as q
+from parityos.operators.circuit import Circuit
+from parityos.operators.controlled_operator import CCX, CRX
+from parityos.operators.elementary_operator import SDg, Swap, TDg
+
+######################################################
+##  Additional Circuits
+######################################################
+
+# 17
+pc17 = Circuit(
+    [
+        SDg(q(0)),
+        TDg(q(0)),
+    ]
+).measure_all()
+
+# 18
+pc18 = Circuit([CRX(q(0), q(1), 1.0), Swap((q(1), q(2))), CCX((q(0), q(2)), q(3))]).measure_all()
+
+
+ADDITIONAL_PARITYOS_CIRCUITS: list[Circuit[Qubit]] = [pc17, pc18]
+
+
+"""
+This string is used by the filecheck tests for matching.
+
+# 0:
+#    ┌───┐
+# 0: ┤ X ├
+#    └───┘
+CHECK-LABEL:  CIRCUIT NUMBER 0
+CHECK:        %n_qubits = arith.constant 1 : i64
+CHECK:        %register = quake.alloca !quake.veq<?>[%n_qubits : i64]
+CHECK:        %[[q0:.+]] = quake.extract_ref %register[0] : (!quake.veq<?>) -> !quake.ref
+CHECK-DAG:    quake.x %[[q0]] : (!quake.ref) -> ()
+CHECK:        return
+
+# 1
+#    ┌───────┐
+# 1: ┤ Rx(2) ├
+#    └───────┘
+CHECK-LABEL:  CIRCUIT NUMBER 1
+CHECK:        %n_qubits = arith.constant 1 : i64
+CHECK:        %register = quake.alloca !quake.veq<?>[%n_qubits : i64]
+CHECK:        %[[q1:.+]] = quake.extract_ref %register[0] : (!quake.veq<?>) -> !quake.ref
+CHECK-DAG:    %[[a0:.+]] = arith.constant 2.0 : f64
+CHECK-DAG:    quake.rx (%[[a0]]) %[[q1]] : (f64, !quake.ref) -> ()
+CHECK:        return
+
+# 2
+#    ┌───────────────────┐
+# a: ┤ Rz(2*phi - theta) ├
+#    └───────────────────┘
+CHECK-LABEL:  CIRCUIT NUMBER 2
+CHECK:        NOT SUPPORTED
+Symbolics not allowed
+
+# 3
+#         ┌─────────────┐
+# (0, 0): ┤ Rx(2*theta) ├
+#         └──────┬──────┘
+#      c: ───────■───────
+CHECK-LABEL:  CIRCUIT NUMBER 3
+CHECK:        NOT SUPPORTED
+Symbolics not allowed
+
+# 4
+#      ┌───────┐┌───┐┌───┐
+#   a: ┤ Rx(2) ├┤ H ├┤ Z ├
+#      └───────┘├───┤└───┘
+#   b: ─────────┤ X ├─────
+#        ┌───┐  └─┬─┘
+#   c: ──┤ X ├────■───────
+#        └───┘
+CHECK-LABEL:  CIRCUIT NUMBER 4
+CHECK:        %n_qubits = arith.constant 3 : i64
+CHECK:        %register = quake.alloca !quake.veq<?>[%n_qubits : i64]
+CHECK-DAG:    %[[a:.+]] = quake.extract_ref %register[0] : (!quake.veq<?>) -> !quake.ref
+CHECK-DAG:    %[[b:.+]] = quake.extract_ref %register[1] : (!quake.veq<?>) -> !quake.ref
+CHECK-DAG:    %[[c:.+]] = quake.extract_ref %register[2] : (!quake.veq<?>) -> !quake.ref
+CHECK-DAG:    %[[angle:.+]] = arith.constant 2.0 : f64
+CHECK-DAG:    quake.rx (%[[angle]]) %[[a]] : (f64, !quake.ref) -> ()
+CHECK-DAG:    quake.h %[[a]] : (!quake.ref) -> ()
+CHECK-DAG:    quake.x %[[c]] : (!quake.ref) -> ()
+CHECK-DAG:    quake.x [%[[c]]] %[[b]] : (!quake.ref, !quake.ref) -> ()
+CHECK-DAG:    quake.z %[[a]] : (!quake.ref) -> ()
+CHECK:        return
+
+# 5
+#      ┌───┐┌──────────────────       ───────┐
+#   0: ┤ H ├┤                   ──■──        ├──────
+#      ├───┤│ If-0 c[0] ^ c[1]  ┌─┴─┐  End-0 │
+#   1: ┤ H ├┤                   ┤ X ├        ├───■──
+#      └───┘└────────╥───────── └───┘ ───────┘ ┌─┴─┐
+#   2: ──────────────╫─────────────────────────┤ X ├
+#                ┌───╨────┐                    └───┘
+# c: 2/══════════╡ [expr] ╞═════════════════════════
+#                └────────┘
+CHECK-LABEL:  CIRCUIT NUMBER 5
+CHECK:        NOT SUPPORTED
+Classical conditions not supported
+
+# 6
+#      ┌───┐┌─┐
+#   0: ┤ H ├┤M├──────
+#      ├───┤└╥┘┌─┐
+#   1: ┤ H ├─╫─┤M├───
+#      ├───┤ ║ └╥┘┌─┐
+#   2: ┤ H ├─╫──╫─┤M├
+#      └───┘ ║  ║ └╥┘
+# c: 3/══════╩══╩══╩═
+#            0  1  2
+CHECK-LABEL:  CIRCUIT NUMBER 6
+CHECK:        %n_qubits = arith.constant 3 : i64
+CHECK:        %register = quake.alloca !quake.veq<?>[%n_qubits : i64]
+CHECK-DAG:    %[[q0:.+]] = quake.extract_ref %register[0] : (!quake.veq<?>) -> !quake.ref
+CHECK-DAG:    %[[q1:.+]] = quake.extract_ref %register[1] : (!quake.veq<?>) -> !quake.ref
+CHECK-DAG:    %[[q2:.+]] = quake.extract_ref %register[2] : (!quake.veq<?>) -> !quake.ref
+CHECK-DAG:    quake.h %[[q0]] : (!quake.ref) -> ()
+CHECK-DAG:    quake.h %[[q1]] : (!quake.ref) -> ()
+CHECK-DAG:    quake.h %[[q2]] : (!quake.ref) -> ()
+CHECK-DAG:    %[[m0:.+]] = quake.mz %[[q0]] : (!quake.ref) -> !quake.measure
+CHECK-DAG:    %[[m1:.+]] = quake.mz %[[q1]] : (!quake.ref) -> !quake.measure
+CHECK-DAG:    %[[m2:.+]] = quake.mz %[[q2]] : (!quake.ref) -> !quake.measure
+CHECK:        return
+
+# 7
+#      ┌───┐┌───┐┌─┐┌───┐                                                       ┌─┐
+#   a: ┤ Z ├┤ H ├┤M├┤ H ├───────────────────────────────────────────────────────┤M├───
+#      ├───┤├───┤└╥┘└┬─┬┘┌───┐                                             ┌───┐└╥┘┌─┐
+#   b: ┤ X ├┤ H ├─╫──┤M├─┤ H ├─────────────────────────────────────────────┤ Z ├─╫─┤M├
+#      └───┘└───┘ ║  └╥┘ └───┘┌──────────────────────────── ┌───┐ ───────┐ └┬─┬┘ ║ └╥┘
+#   c: ───────────╫───╫───────┤ If-0 (c[1] | c[3]) == true  ┤ X ├  End-0 ├──┤M├──╫──╫─
+#                 ║   ║       └─────────────╥────────────── └───┘ ───────┘  └╥┘  ║  ║
+#                 ║   ║                 ┌───╨────┐                           ║   ║  ║
+# c: 5/═══════════╩═══╩═════════════════╡ [expr] ╞═══════════════════════════╩═══╩══╩═
+#                 1   3                 └────────┘                           0   2  4
+CHECK-LABEL:  CIRCUIT NUMBER 7
+CHECK:        NOT SUPPORTED
+Classical conditions not supported
+
+# 8
+#    ┌───┐
+# 0: ┤ X ├──■──────────────────────────────────────────■─
+#    └─┬─┘┌─┴─┐┌──────────────┐     ┌───────────┐      │
+# 1: ──┼──┤ X ├┤0             ├─────┤0          ├──────┼─
+#      │  └───┘│  Rxx(-2*phi) │     │           │      │
+# 2: ──┼───────┤1             ├──■──┤  Rzz(phi) ├──■───■─
+#      │       └──────────────┘  │  │           │  │   │
+# 3: ──■─────────────────────────┼──┤1          ├──┼───┼─
+#                              ┌─┴─┐└─────┬─────┘  │   │
+# 4: ──────────────────────────┤ X ├──────■────────■───■─
+#                              └───┘             ┌─┴─┐
+# 5: ────────────────────────────────────────────┤ Y ├───
+#                                                └───┘
+CHECK-LABEL:  CIRCUIT NUMBER 8
+CHECK:        NOT SUPPORTED
+RZZ gate not supported
+
+# 9
+#    ┌───┐     ┌───┐
+# 0: ┤ H ├─|0>─┤ H ├
+#    └───┘     └───┘
+CHECK-LABEL:  CIRCUIT NUMBER 9
+CHECK:        %n_qubits = arith.constant 1 : i64
+CHECK:        %register = quake.alloca !quake.veq<?>[%n_qubits : i64]
+CHECK-DAG:    %[[q0:.+]] = quake.extract_ref %register[0] : (!quake.veq<?>) -> !quake.ref
+CHECK-DAG:    quake.h %[[q0]] : (!quake.ref) -> ()
+CHECK-DAG:    quake.reset %[[q0]] : (!quake.ref) -> ()
+CHECK-DAG:    quake.h %[[q0]] : (!quake.ref) -> ()
+CHECK:        return
+
+# 10
+#    ┌────┐┌───┐┌─────┐┌──────┐┌─────┐┌───┐
+# 0: ┤ √X ├┤ T ├┤ Tdg ├┤ √Xdg ├┤ Sdg ├┤ S ├
+#    └────┘└───┘└─────┘└──────┘└─────┘└───┘
+CHECK-LABEL:  CIRCUIT NUMBER 10
+CHECK:        NOT SUPPORTED
+SX gate not supported
+
+# 11
+#               ┌────────────┐
+# 0: ───────────┤0           ├
+#               │  Rxx(0.25) │
+# 1: ─■─────────┤1           ├
+#     │ZZ(0.75) └────────────┘
+# 2: ─■───────────────────────
+CHECK-LABEL:  CIRCUIT NUMBER 11
+CHECK:        NOT SUPPORTED
+RZZ gate not supported
+
+# 12
+#        ┌──────  ┌───┐ ───────┐
+#   0: ──┤ If-0  ─┤ X ├  End-0 ├─
+#        └──╥───  └───┘ ───────┘
+#      ┌────╨────┐
+# c: 1/╡ c_0=0x1 ╞═══════════════
+#      └─────────┘
+CHECK-LABEL:  CIRCUIT NUMBER 12
+CHECK:        NOT SUPPORTED
+Classical conditions not supported
+
+# 13
+#        ┌──────  ┌───┐ ───────┐
+#   q: ──┤ If-0  ─┤ X ├  End-0 ├─
+#        └──╥───  └───┘ ───────┘
+#      ┌────╨────┐
+# c: 1/╡ c_0=0x0 ╞═══════════════
+#      └─────────┘
+CHECK-LABEL:  CIRCUIT NUMBER 13
+CHECK:        NOT SUPPORTED
+Classical conditions not supported
+
+# 14
+#      ┌──────────────────────────── ┌───┐ ───────┐ ┌─────────────────────────────────── ┌───┐ ───────┐
+#   q: ┤ If-0 (c[0] | c[2]) == true  ┤ X ├  End-0 ├─┤ If-0 (c[0] ^ c[1] ^ c[2]) == true  ┤ Z ├  End-0 ├─
+#      └─────────────╥────────────── └───┘ ───────┘ └─────────────────╥───────────────── └───┘ ───────┘
+#                ┌───╨────┐                                       ┌───╨────┐
+# c: 3/══════════╡ [expr] ╞═══════════════════════════════════════╡ [expr] ╞════════════════════════════
+#                └────────┘                                       └────────┘
+CHECK-LABEL:  CIRCUIT NUMBER 14
+CHECK:        NOT SUPPORTED
+Classical conditions not supported
+
+# 15
+#      ┌─────────────────────────────────────────┐   ┌─────────────┐   ┌───────────────────────────────────┐
+# q_0: ┤0                                        ├───┤ Rx(2*theta) ├───┤0                                  ├
+#      │                                         │   └─────────────┘   │                                   │
+# q_1: ┤1                                        ├─────────────────────┤1                                  ├
+#      │                                         │                     │  exp(-it (IIII + IYXZ + XZYI))(1) │
+# q_2: ┤2 exp(-it (IIYX + XZYI + ZIZI))(0.5*phi) ├─────────────────────┤2                                  ├
+#      │                                         │┌───────────────────┐│                                   │
+# q_3: ┤                                         ├┤ Ry((-3.14)*theta) ├┤3                                  ├
+#      │                                         │└───────────────────┘└───────────────────────────────────┘
+# q_4: ┤3                                        ├──────────────────────────────────────────────────────────
+#      └─────────────────────────────────────────┘
+CHECK-LABEL:  CIRCUIT NUMBER 15
+CHECK:        NOT SUPPORTED
+Symbolics not supported
+
+# 16
+#      ┌───────┐┌──────────────────────┐
+# q_0: ┤ Rx(π) ├┤0                     ├
+#      └───────┘│  (XX+YY)((-2)*phi,0) │
+# q_1: ─────────┤1                     ├
+#               └──────────────────────┘
+CHECK-LABEL:  CIRCUIT NUMBER 16
+CHECK:        NOT SUPPORTED
+Symbolics not supported
+
+# 17
+#            ░       ░ ┌───┐
+# q_0: ──────░───────░─┤ H ├
+#      ┌───┐ ░ ┌───┐ ░ └───┘
+# q_1: ┤ X ├─░─┤ X ├─░──────
+#      └───┘ ░ └───┘ ░
+# q_2: ──────────────░───■──
+#                    ░ ┌─┴─┐
+# q_3: ──────────────░─┤ X ├
+#                    ░ └───┘
+CHECK-LABEL:  CIRCUIT NUMBER 17
+CHECK:        NOT SUPPORTED
+Barriers not supported
+
+CHECK-LABEL:  CIRCUIT NUMBER 18
+CHECK:        %n_qubits = arith.constant 1 : i64
+CHECK:        %register = quake.alloca !quake.veq<?>[%n_qubits : i64]
+CHECK-DAG:    %[[q0:.+]] = quake.extract_ref %register[0] : (!quake.veq<?>) -> !quake.ref
+CHECK-DAG:    quake.s<adj> %[[q0]] : (!quake.ref) -> ()
+CHECK-DAG:    quake.t<adj> %[[q0]] : (!quake.ref) -> ()
+CHECK:        return
+
+CHECK-LABEL:  CIRCUIT NUMBER 19
+CHECK:        %n_qubits = arith.constant 4 : i64
+CHECK:        %register = quake.alloca !quake.veq<?>[%n_qubits : i64]
+CHECK:        %[[q1:.+]] = quake.extract_ref %register[0] : (!quake.veq<?>) -> !quake.ref
+CHECK:        %[[q2:.+]] = quake.extract_ref %register[1] : (!quake.veq<?>) -> !quake.ref
+CHECK:        %[[q3:.+]] = quake.extract_ref %register[2] : (!quake.veq<?>) -> !quake.ref
+CHECK:        %[[q4:.+]] = quake.extract_ref %register[3] : (!quake.veq<?>) -> !quake.ref
+CHECK-DAG:    %[[angle:.+]] = arith.constant 1.0 : f64
+CHECK-DAG:    quake.rx (%[[angle]]) [%[[q1]]] %[[q2]] : (f64, !quake.ref, !quake.ref) -> ()
+CHECK-DAG:    quake.swap %[[q2]], %[[q3]] : (!quake.ref, !quake.ref) -> ()
+CHECK-DAG:    quake.x [%[[q1]], %[[q3]]] %[[q4]] : (!quake.ref, !quake.ref, !quake.ref) -> ()
+CHECK:        return
+"""

parityos_cudaq-0.1.0/test_parityos_cudaq/test_quake_exporter.py

@@ -0,0 +1,87 @@
+# ParityQC © 2025. See the LICENSE file in the top level directory for details.
+import shutil
+import subprocess
+from typing import final
+
+import pytest
+from filecheck.matcher import Matcher
+from filecheck.options import Options
+from parityos.bits import Qubit
+from parityos.operators.circuit import CircuitLike
+from parityos.utils.exceptions import ParityOSNotSupportedError
+from parityos_cudaq.exporter import export_parityos_to_quake
+from parityos_testutils.exporters.parityos_circuits import PARITYOS_CIRCUITS
+
+from .quake_circuits import ADDITIONAL_PARITYOS_CIRCUITS
+
+CUSTOM_PARITYOS_CIRCUITS = PARITYOS_CIRCUITS + ADDITIONAL_PARITYOS_CIRCUITS
+
+
+def check_qudaq_opt_installation() -> bool:
+    """Checks if qudaq-opt is on the PATH."""
+    return bool(shutil.which("cudaq-opt"))
+
+
+@final
+class TestQuakeExporterCudaQ:
+    """Class to test that cudaq understands the exporter output.
+
+    These tests require the cudaq-opt binary to be available on the PATH, which is not expected in the CI.
+    To support them,
+     - Install a cudaq-opt binary.
+     - Make sure that cudaq-opt is on the PATH during python execution, such as the /venv/bin
+       directory.
+    """
+
+    @pytest.mark.skipif(not check_qudaq_opt_installation(), reason="cudaq-opt not installed")
+    @pytest.mark.parametrize(
+        "parityos_circuit",
+        CUSTOM_PARITYOS_CIRCUITS,
+        ids=[i for i, _ in enumerate(CUSTOM_PARITYOS_CIRCUITS)],
+    )
+    def test_qudaq_opt_successful_execution(self, parityos_circuit: CircuitLike[Qubit]):
+        """Tests successful qudaq-opt round trip on exported circuits."""
+        try:
+            quake_module = export_parityos_to_quake(parityos_circuit, True).module
+        except ParityOSNotSupportedError:
+            # Unsupported
+            return
+
+        cudaq_binary = str(shutil.which("cudaq-opt"))  # The subprocess has no access to the PATH.
+        try:
+            subprocess.run(
+                [cudaq_binary],
+                input=quake_module,
+                capture_output=True,
+                text=True,
+                check=True,  # Raise exception on non-zero exit code
+            )
+        except subprocess.CalledProcessError as e:
+            pytest.fail(
+                f"Test circuit did not pass cudaq-opt round trip (likely invalid syntax): {e}"
+            )
+
+
+@final
+class TestQuakeExportWithFileCheck:
+    """Class to run FileCheck tests."""
+
+    def test_quake_export(self, tmp_path):
+        from .quake_circuits import __file__ as match_filename
+
+        tmp_filename = tmp_path / "_quake_output.tmp.qke"
+        with open(tmp_filename, "w") as tmp_file:
+            for i, parityos_circuit in enumerate(CUSTOM_PARITYOS_CIRCUITS):
+                tmp_file.write(f"// CIRCUIT NUMBER {i}\n")
+                try:
+                    export_result = export_parityos_to_quake(parityos_circuit, True)
+                    tmp_file.write(export_result.module)
+                except ParityOSNotSupportedError:
+                    tmp_file.write("// NOT SUPPORTED\n")
+
+        filecheck_options = Options(match_filename=match_filename, input_file=str(tmp_filename))
+        matcher = Matcher.from_opts(filecheck_options)
+        exitcode = matcher.run()
+
+        if exitcode != 0:
+            pytest.fail(f"Filecheck failed with exit code {exitcode}")