perceval-interop 1.2.0__py3-none-any.whl

perceval_interop/__init__.py

@@ -0,0 +1,27 @@
+# MIT License
+#
+# Copyright (c) 2025 Quandela
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from .abstract_converter import AGateConverter
+from .myqlm import MyQLMConverter, MyQLMHelper, QuandelaQPUHandler
+from .qiskit import QiskitConverter, StatevectorConverter, CircuitToGraphConverter
+from .cqasm import CQASMConverter
+from .utils import *

perceval_interop/abstract_converter.py

@@ -0,0 +1,221 @@
+# MIT License
+#
+# Copyright (c) 2025 Quandela
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from perceval.components import Port, Circuit, Processor, catalog, AProcessor
+from perceval.utils import P, BasicState, Encoding, global_params, PostSelect, NoiseModel
+from perceval.utils.algorithms.optimize import optimize
+from perceval.utils.algorithms.norm import frobenius
+import perceval.components.unitary_components as comp
+from perceval_interop.utils.converter_utils import label_cnots_in_gate_sequence
+
+def _create_mode_map(c_idx: int, c_data: int) -> dict:
+    return {c_idx: 0, c_idx + 1: 1, c_data: 2, c_data + 1: 3}
+
+
+class UnknownGateError(Exception):
+    pass
+
+
+class AGateConverter(ABC):
+    r"""
+    Converter class for gate based Circuits to perceval processor
+    """
+
+    def __init__(self, backend_name: str = "SLOS", noise_model: NoiseModel = None):
+        self._converted_processor: AProcessor | None = None  # TODO: replace by Experiment?
+        self._input_list = None  # input state in list
+        self._noise_model = noise_model
+        self._backend_name = backend_name
+
+        # Define function handler to create complex components
+        # Users could override them
+        self.create_hcnot_processor = catalog["heralded cnot"].build_processor
+        self.create_hcz_processor = catalog["heralded cz"].build_processor
+        self.create_ppcnot_processor = catalog["postprocessed cnot"].build_processor
+        self.create_generic_2mode_circuit = catalog["generic 2 mode circuit"].build_circuit
+        self.create_lower_phase_circuit = lambda: Circuit(2) // (0, comp.PS(P("phi2")))
+        self.create_upper_phase_circuit = lambda: Circuit(2) // (1, comp.PS(P("phi1")))
+        self.create_2phase_circuit = lambda: Circuit(2) // (0, comp.PS(P("phi1"))) // (1, comp.PS(P("phi2")))
+
+    @abstractmethod
+    def count_qubits(self, gate_circuit) -> int:
+        pass
+
+    @abstractmethod
+    def _get_gate_sequence(self, gate_circuit) -> list[list]:
+        """
+        Iterates over the gate circuit to return a list of Gate operations in the circuit to convert to LO circuit.
+        The information in each element of the list is  - [gate name, gate qubit positions, gate parameters, gate unitary]
+        Note - Gate parameter or gate unitary can be None if value is not needed.
+        """
+        pass
+
+    @abstractmethod
+    def _get_qubit_names(self, gate_circuit, n_qbits) -> list:
+        """
+        Returns a list of Qubit names for a given 'n_qubits' gate circuit. Use 'Q' as the default name
+         unless the framework provides a custom name.
+        """
+        pass
+
+    def _configure_processor(self, gate_circuit, **kwargs):
+        """
+        Sets port Encoding and default input state for the Processor
+        """
+        n_qbits = self.count_qubits(gate_circuit)
+        qubit_names = self._get_qubit_names(gate_circuit, n_qbits)
+
+        n_moi = n_qbits * 2  # In dual rail, number of modes of interest = 2 * number of qbits
+        self._input_list = [0] * n_moi
+        self._converted_processor = Processor(self._backend_name, n_moi, noise=self._noise_model)
+        for i in range(n_qbits):
+            self._converted_processor.add_port(i * 2, Port(Encoding.DUAL_RAIL, qubit_names[i]))
+            self._input_list[i * 2] = 1
+
+    def apply_input_state(self):
+        default_input_state = BasicState(self._input_list)
+        self._converted_processor.min_detected_photons_filter(default_input_state.n)
+        self._converted_processor.with_input(default_input_state)
+
+    def convert(self, gate_circuit, use_postselection: bool = True) -> Processor:
+        """Convert a gate-based quantum circuit into a `Processor`.
+
+        :param gate_circuit: gate-based quantum circuit (Qiskit, Myqlm or CQASM)
+        :param use_postselection: when True (default), uses optimized number of `postprocessed CNOT` and
+            'Heralded CNOT' gates. Otherwise, uses only `heralded CNOT`.
+
+        :return: the converted processor
+        """
+        self._configure_processor(gate_circuit)  # empty processor with ports initialized
+        gate_sequence = self._get_gate_sequence(gate_circuit)
+
+        return self._generate_converted_processor(gate_sequence, use_postselection=use_postselection)
+
+    def _generate_converted_processor(self, gate_sequence: list, use_postselection: bool) -> Processor:
+        # gate_inf -> [gate name, gate qubit pos, gate parameter if any or None, unitary Matrix or None]
+
+        optimized_gate_sequence = label_cnots_in_gate_sequence(gate_sequence)
+
+        for gate_index, gate_inf in enumerate(gate_sequence):
+            gate_name = gate_inf[0]
+
+            if len(gate_inf[1]) == 1:
+                if gate_name in catalog:
+                    gate_param = gate_inf[2]
+                    ins = self._create_catalog_1_qubit_gate(gate_name, param=gate_param)
+                else:
+                    ins = self._create_generic_1_qubit_gate(gate_inf[3])
+                    ins._name = gate_inf[0]
+                self._converted_processor.add(gate_inf[1][0] * 2, ins.copy())
+
+            else:
+                if len(gate_inf[1]) > 2:
+                    raise NotImplementedError("2+ Qubit gates not implemented")
+
+                c_idx = gate_inf[1][0] * 2
+                c_data = gate_inf[1][1] * 2
+                self._create_2_qubit_gates_from_catalog(optimized_gate_sequence[gate_index], c_idx, c_data,
+                                                        use_postselection)
+        self.apply_input_state()
+        return self._converted_processor
+
+    def _create_catalog_1_qubit_gate(self, gate_name: str, **kwargs) -> Processor:
+        param = kwargs.get("param", None)
+        if gate_name in ["rx", "ry", "rz"]:
+            return catalog[gate_name].build_processor(theta=param)
+        elif gate_name in ["ph"]:
+            return catalog[gate_name].build_processor(phi=param)
+        else:
+            return catalog[gate_name].build_processor()
+
+    def _create_generic_1_qubit_gate(self, u) -> Circuit:
+        # universal method, takes in unitary and approximates one using
+        # Frobenius method
+        if abs(u[1, 0]) + abs(u[0, 1]) < 2 * global_params["min_precision_gate"]:
+            # diagonal matrix - we can handle with phases, we consider that gate unitary parameters has
+            # limited numeric precision
+            if abs(u[0, 0] - 1) < global_params["min_precision_gate"]:
+                if abs(u[1, 1] - 1) < global_params["min_precision_gate"]:
+                    return Circuit(2, name="I")  # returns Identity/empty circuit
+                ins = self.create_upper_phase_circuit()
+            else:
+                if abs(u[1, 1] - 1) < global_params["min_precision_gate"]:
+                    ins = self.create_lower_phase_circuit()
+                else:
+                    ins = self.create_2phase_circuit()
+            optimize(ins, u, frobenius, sign=-1)
+        else:
+            ins = self.create_generic_2mode_circuit()
+            optimize(ins, u, frobenius, sign=-1)
+        return ins
+
+    def _create_2_qubit_gates_from_catalog(self, gate_name: str, c_idx: int, c_data: int, use_postselection: bool):
+        r"""
+        List of Gates implemented:
+        CNOT - Heralded and post-processed
+        CZ - Heralded
+        CRz - Heralded and post-processed (uses two CNOTs)
+        SWAP
+        """
+        # Save and clear current post-selection data from the converted processor before adding the next gate
+        if self._converted_processor.post_select_fn is not None:
+            post_select_curr = self._converted_processor.post_select_fn
+        else:
+            post_select_curr = PostSelect()  # save empty if I need to merge incoming PostSelect to it
+        self._converted_processor.clear_postselection()  # clear current post-selection
+
+        gate_name = gate_name.upper()
+        if gate_name in ["POSTPROCESSED CNOT", "HERALDED CNOT"]:
+            if use_postselection and gate_name == "POSTPROCESSED CNOT":
+                cnot_processor = self.create_ppcnot_processor()
+            else:
+                cnot_processor = self.create_hcnot_processor()
+
+            self._converted_processor.add(_create_mode_map(c_idx, c_data), cnot_processor)
+            if self._converted_processor.post_select_fn is not None:
+                post_select_curr.merge(self._converted_processor.post_select_fn)
+
+        elif gate_name in ["CSIGN", "CZ"]:
+            # Controlled Z in myqlm is named CSIGN
+            cz_processor = self.create_hcz_processor()
+            self._converted_processor.add(_create_mode_map(c_idx, c_data), cz_processor)
+        elif gate_name == "SWAP":
+            # Works for any FIRST and LAST, everything in-between is unchanged.
+            c_first = min(c_idx, c_data)
+            c_last = max(c_idx, c_data)
+            n = (c_last - c_first) // 2 + 1
+            perm = [i for i in range(n * 2)]
+            perm[0] = c_last - c_first
+            perm[1] = perm[0] + 1
+            perm[perm[0]] = 0
+            perm[perm[1]] = 1
+            self._converted_processor.add(c_first, comp.PERM(perm))
+        else:
+            raise UnknownGateError(f"Gate not yet supported: {gate_name}")
+
+        # re-apply the cleared post-selection
+        self._converted_processor.set_postselection(post_select_curr)
+        return self._converted_processor

perceval_interop/cqasm/__init__.py

@@ -0,0 +1,26 @@
+# MIT License
+#
+# Copyright (c) 2025 Quandela
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+try:
+    from .cqasm_converter import CQASMConverter
+except ModuleNotFoundError:
+    from perceval_interop.utils import MissingDependency
+    CQASMConverter = MissingDependency("CQASMConverter", "cqasm")

perceval_interop/cqasm/cqasm_converter.py

@@ -0,0 +1,346 @@
+# MIT License
+#
+# Copyright (c) 2025 Quandela
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from perceval.components import Processor, catalog
+from perceval.utils.logging import get_logger, channel
+from perceval.utils import NoiseModel
+from perceval_interop.abstract_converter import AGateConverter
+from perceval_interop.utils import ConversionSyntaxError, ConversionUnsupportedFeatureError, ConversionBadVersionError
+
+import cqasm.v3x as cqasm
+import numpy as np
+import re
+
+# A collection of gates for which meaningful optical circuits (beam splitter,
+# phase shifter, permutation) exist.
+# Source:
+# https://qutech-delft.github.io/cQASM-spec/language_specification/instructions/gates.html#standard-gate-set
+
+_CQASM_1_QUBIT_GATES = {
+    "H", "X", "X90", "mX90", "Rx", "Y", "Y90", "mY90", "Ry", "S", "Sdag", "T", "Tdag", "Z", "Rz",
+    # For v1 compatibility
+    "I"
+}
+
+_CQASM_2_QUBIT_GATES = { "CNOT", "CZ"}
+
+
+class CQASMConverter(AGateConverter):
+    r"""cQASM quantum circuit to perceval processor converter.
+
+    :param backend_name: backend name used in the converted processor (default SLOS)
+    """
+    def __init__(self, backend_name: str = "SLOS", noise_model: NoiseModel = None):
+        super().__init__(backend_name, noise_model)
+        self._qubit_list = []
+
+    def count_qubits(self, ast) -> int:
+        return len(self._qubit_list)
+
+    def _collect_qubit_list(self, ast):
+        self._qubit_list = []
+        for variable in ast.variables:
+            if type(variable.typ) is cqasm.types.QubitArray:
+                for i in range(variable.typ.size):
+                    self._qubit_list.append((variable.name, i))
+            elif type(variable.typ) is cqasm.types.Qubit:
+                self._qubit_list.append((variable.name, -1))
+            else:
+                raise ConversionUnsupportedFeatureError(f"Classical variable { variable.name } not supported")
+
+    def _operand_to_qubit_indices(self, operand):
+        name = operand.variable.name
+        if type(operand) is cqasm.values.VariableRef:
+            return [self._qubit_list.index((name, -1))]
+        elif type(operand) is cqasm.values.IndexRef:
+            return [self._qubit_list.index((name, index.value))
+                      for index in operand.indices]
+        else:
+            raise ConversionUnsupportedFeatureError(f"Cannot map variable { name } to a declared qubit")
+
+    def _get_gate_info(self, statement):
+        # For each CQASM statement -> gate information - gate name, qubit position, parameter are returned
+        gate_name = statement.gate.name
+        num_operands = len(statement.operands)
+
+        # For now, assume the statement pattern is OP q
+        targets = self._operand_to_qubit_indices(statement.operands[0])
+        controls = []
+        parameter = None
+
+        # Match other statement patterns
+        if num_operands == 1 and len(statement.gate.parameters):
+            # Note: statement.gate.parameters is of type ConstFloat, but changes to MultiValueBase from 1.1.0
+            # get parameters for 1 qubit gates.
+            parameter = statement.gate.parameters[0].value
+        elif num_operands == 2:
+            if type(statement.operands[1]) is cqasm.values.ConstFloat:
+                # Statement pattern is OP(r) q. This case appears when converting 1 qubit gates from v1.
+                parameter = statement.operands[1].value
+            else:
+                # Statement pattern is OP q, q
+                controls = targets
+                targets = self._operand_to_qubit_indices(statement.operands[1])
+        elif num_operands == 3:
+            # Statement is OP(r) q, q
+            controls = targets
+            targets = self._operand_to_qubit_indices(statement.operands[1])
+            parameter = statement.operands[2].value
+        elif num_operands >= 4:
+            raise ConversionUnsupportedFeatureError(f"Statement with unsupported number of operands, n = { num_operands }")
+
+        return gate_name, controls, targets, parameter
+
+    def _get_gate_sequence(self, ast) -> list[list]:
+        # generates the gate sequence by converting ast statements
+        gate_sequence = []
+        for statement in ast.block.statements:
+            gate_name, controls, targets, parameter = self._get_gate_info(statement)
+
+            parameter = CQASMConverter._update_parameter_rotation_gate(gate_name, parameter)
+            # x90, mx90, y90, my90 are named gates in CQASM. Their parameter values are needed to build circuit in pcvl.
+
+            gate_name = CQASMConverter._map_gate(gate_name)
+
+            if not controls:
+                # working with 1 qubit gates
+                if gate_name.lower() in catalog:
+                    for i in range(len(targets)):
+                        gate_sequence.append([gate_name.lower(), [targets[i]], parameter])
+                else:
+                    raise ConversionUnsupportedFeatureError(f"Unsupported 1-qubit gate {gate_name}")
+            else:
+                if gate_name not in _CQASM_2_QUBIT_GATES:
+                    raise ConversionUnsupportedFeatureError(
+                        f"Unsupported 2-qubit gate { gate_name }")
+                for target in targets:
+                    gate_sequence.append([gate_name.lower(), [controls[0], target], parameter])
+
+        gate_sequence = [elem + [None] for elem in gate_sequence]  # to be consistent with other frameworks, None is used for gate unitary
+
+        return gate_sequence
+
+    def _get_qubit_names(self, ast, n_qbits):
+        return [f'{q}[{i}]' if i >= 0 else q for (q, i) in self._qubit_list]
+
+    def convert(self, ast, use_postselection: bool = True) -> Processor:
+        r"""Convert a cQASM quantum program into a `Processor`.
+
+        :param ast: the AST of a cQASM program
+        :type ast: a Program object, as returned by the cQASM parser
+        :param use_postselection: when True, uses as many `postprocessed CNOT` as possible.
+                                  Otherwise, uses only `heralded CNOT`
+
+        :return: the converted processor
+        """
+        if isinstance(ast, str):
+            ast = self._convert_from_string(ast)
+
+        get_logger().info(f"Convert cqasm.ast ({len(self._qubit_list)} qubits, {len(ast.block.statements)} operations) to processor",
+                    channel.general)
+        self._collect_qubit_list(ast)
+
+        return super().convert(ast, use_postselection)
+
+    @classmethod
+    def check_version(cls, source_string):
+        r"""Extracts the version number string from a cQASM program
+
+        :param source_string: the cQASM program stored in a string
+        :return: a tuple (major, minor) with the version number
+        """
+        pattern = r"^\s*version ([0-9])(.[0-9])?\s*"
+        match = re.search(pattern, source_string, re.MULTILINE)
+        if match:
+            major = int(match.group(1))
+            minor = int(match.group(2)[1:]) if match.group(2) else 0
+            return major, minor
+        else:
+            raise ConversionSyntaxError(f"Missing version number")
+
+    def _convert_from_string(self, source: str) -> cqasm.semantic.Program:
+        r"""Convert a cQASM quantum program into a `Processor`.
+
+        :param source: a string containing the cQASM program to convert, or the path to a file storing itm
+        :return: the cQASM program
+        """
+        # The string contains a single line, it might be a path
+        if not "\n" in source:
+            try:
+                get_logger().debug(f"Reading cQASM file content at {source}", channel.general)
+                with open(source) as source_file:
+                    source = source_file.read()
+            except IOError:
+                # File not found, It might be a single line program instead
+                # of a name, so we can attempt to parse it.
+                pass
+
+        major, minor = CQASMConverter.check_version(source)
+        if major == 3:
+            get_logger().debug("Parsing cQASM v3 description", channel.general)
+            ast = cqasm.Analyzer().analyze_string(source)
+        elif major == 1:
+            get_logger().debug("Converting cQASM v1 to v3", channel.general)
+            ast = self._v3_ast_from_v1_source(source.split('\n'))
+        else:
+            raise ConversionBadVersionError(f"Unsupported version {major}.{minor}")
+
+        if not isinstance(ast, cqasm.semantic.Program):
+            raise ConversionSyntaxError(f"cQASM parser error: { ast[0] }")
+
+        return ast
+
+    def _v3_ast_from_v1_source(self, lines):
+        r"""Converts a cQASM v1 quantum program into a cQASM v3 AST"""
+
+        # Parsing code from https://github.com/maxwell04-wq original submission,
+        # with just enough changes to make it parse the example on:
+        # https://www.quantum-inspire.com/kbase/cqasm/
+
+        # Create an empty Program object to store the v3 AST
+        ast = cqasm.semantic.Program(
+            api_version=cqasm.primitives.Version([3]),
+            block=cqasm.semantic.Block(
+                statements=cqasm.semantic.MultiStatement()),
+            variables=cqasm.semantic.MultiVariable()
+        )
+
+        def _is_float(ins):
+            try:
+                float(ins)
+                return True
+            except ValueError:
+                return False
+
+        # read QASM instructions line-by-line
+        for line in lines:
+            try:
+                line = line.strip()
+                if len(line) <= 0 or line[0] == '#':
+                    #empty line or comment
+                    continue
+
+                instruction = line.split(" ")
+                if instruction[0] == "version":
+                    continue
+
+                if instruction[0] == "qubits":
+                    if not instruction[1].isdigit():
+                        raise ConversionSyntaxError(
+                                "Qubit number is not an integer.")
+                    typ = cqasm.types.QubitArray(size=int(instruction[1]))
+                    ast.variables.append(
+                        cqasm.semantic.Variable(name='q', typ=typ))
+                    continue
+
+                # Ignore anything with only one keyword:
+                if len(instruction) <= 1:
+                    continue
+
+                # Ignore classical bits
+                if line.find("b[") != -1:
+                    continue
+
+                # Ignore non-gate instructions
+                if instruction[0] in ['prep_z', 'measure']:
+                    continue
+
+                ins_qubits = []
+                theta = None
+                for remaining_token in instruction[1:]:
+                    ins_params = remaining_token.split(",")
+                    for param in ins_params:
+                        if param.find(":") != -1:
+                            raise ConversionSyntaxError(
+                                "Unsuported token.")
+                        start_indx = param.find("q[")
+                        if start_indx != -1:
+                            end_indx = param.find("]")
+                            ins_qubits.append(param[start_indx+2:end_indx])
+                        # Rotation gates
+                        elif _is_float(param):
+                            theta = float(param)
+
+                if len(ins_qubits) > 2:
+                    raise ConversionUnsupportedFeatureError(
+                        f"Gate { instruction[0] } has more than one control (n = { len(ins_params) })"
+                    )
+
+                # Check if valid gate
+                if len(ins_qubits) == 1:
+                    if instruction[0] not in _CQASM_1_QUBIT_GATES:
+                        raise ConversionUnsupportedFeatureError(
+                            f"Unsupported 1-qubit gate { instruction[0] }")
+
+                elif len(ins_qubits) == 2:
+                    if instruction[0] not  in _CQASM_2_QUBIT_GATES:
+                        raise ConversionUnsupportedFeatureError(
+                            f"Unsupported 2-qubit gate { instruction[0] }")
+
+                operands = []
+                for qubit_index in ins_qubits:
+                    index = cqasm.values.IndexRef(
+                        variable=cqasm.semantic.Variable(name = 'q'))
+                    index.indices = cqasm.values.MultiConstInt()
+                    index.indices.append(cqasm.values.ConstInt(qubit_index))
+                    operands.append(index)
+                if theta is not None:
+                    angle = cqasm.values.ConstFloat(value=theta)
+                    operands.append(angle)
+
+                statement = cqasm.semantic.GateInstruction(
+                    gate=cqasm.semantic.Gate(f"{instruction[0]}"),
+                    operands=operands)  # operand=[qubits, parameters]
+                ast.block.statements.append(statement)
+            except ValueError:
+                print("An error in parsing the cQASM v1 file.")
+        return ast
+
+    @staticmethod
+    def _map_gate(gate_name: str) -> str:
+        # updates gate names to be consistent with Perceval catalog
+        if gate_name == 'X90':
+            return 'rx'
+
+        elif gate_name == 'mX90':
+            return 'rx'
+        elif gate_name == 'Y90':
+            return 'ry'
+        elif gate_name == 'mY90':
+            return 'ry'
+        else:
+            return gate_name
+
+    @staticmethod
+    def _update_parameter_rotation_gate(gate_name, parameter) -> float:
+        # Returns circuit parameter value for CQASM gates
+        if gate_name == 'X90':
+            return np.pi / 2
+
+        elif gate_name == 'mX90':
+            return - np.pi / 2
+        elif gate_name == 'Y90':
+            return np.pi / 2
+        elif gate_name == 'mY90':
+            return - np.pi / 2
+        else:
+            return parameter

perceval_interop/myqlm/__init__.py

@@ -0,0 +1,32 @@
+# MIT License
+#
+# Copyright (c) 2025 Quandela
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+try:
+    from .myqlm_converter import MyQLMConverter
+    from .myqlm_helper import MyQLMHelper
+    from .qpu_handler import QuandelaQPUHandler
+
+except ModuleNotFoundError:
+    from perceval_interop.utils import MissingDependency
+    extra_name = "myqlm"
+    MyQLMConverter = MissingDependency("MyQLMConverter", extra_name)
+    MyQLMHelper = MissingDependency("MyQLMHelper", extra_name)
+    QuandelaQPUHandler = MissingDependency("QuandelaQPUHandler", extra_name)