iqm-client 30.2.0__py3-none-any.whl → 31.1.0__py3-none-any.whl

iqm/cirq_iqm/serialize.py

@@ -14,6 +14,8 @@
 
 """Helper functions for serializing and deserializing quantum circuits between Cirq and IQM circuit formats."""
 
+from math import pi
+
 from cirq import Circuit, KeyCondition, NamedQid
 from cirq.ops import (
     ClassicallyControlledOperation,
@@ -26,9 +28,10 @@ from cirq.ops import (
     XPowGate,
     YPowGate,
 )
-from iqm import iqm_client
 from iqm.cirq_iqm.iqm_gates import IQMMoveGate
-from iqm.iqm_client import Instruction
+
+import iqm.pulse
+from iqm.pulse import CircuitOperation
 
 # Mapping from IQM operation names to cirq operations
 _IQM_CIRQ_OP_MAP: dict[str, tuple[type[Gate], ...]] = {
@@ -43,11 +46,11 @@ _IQM_CIRQ_OP_MAP: dict[str, tuple[type[Gate], ...]] = {
 }
 
 
-def instruction_to_operation(instr: Instruction) -> Operation:
-    """Convert an IQM instruction to a Cirq Operation.
+def circuit_operation_to_operation(circuit_operation: CircuitOperation) -> Operation:
+    """Convert an IQM circuit operation to a Cirq Operation.
 
     Args:
-        instr: the IQM instruction
+        circuit_operation: the IQM circuit_operation
 
     Returns:
         Operation: the converted operation
@@ -56,23 +59,29 @@ def instruction_to_operation(instr: Instruction) -> Operation:
         OperationNotSupportedError When the circuit contains an unsupported operation.
 
     """
-    if instr.name not in _IQM_CIRQ_OP_MAP:
-        raise OperationNotSupportedError(f"Operation {instr.name} not supported.")
+    if circuit_operation.name not in _IQM_CIRQ_OP_MAP:
+        raise OperationNotSupportedError(f"Operation {circuit_operation.name} not supported.")
 
-    qubits = [NamedQid(qubit, dimension=2) for qubit in instr.qubits]
+    qubits = [NamedQid(qubit, dimension=2) for qubit in circuit_operation.locus]
 
-    if instr.name == "cc_prx":
+    if circuit_operation.name == "cc_prx":
         # special case
-        args = {"exponent": 2 * instr.args["angle_t"], "phase_exponent": 2 * instr.args["phase_t"]}
+        args = {
+            "exponent": circuit_operation.args["angle"] / pi,
+            "phase_exponent": circuit_operation.args["phase"] / pi,
+        }
         # ignore feedback_qubit, we currently only support 1-qubit KeyConditions so it can be
         # added in serialize_circuit
-        return PhasedXPowGate(**args)(*qubits).with_classical_controls(instr.args["feedback_key"])
-
-    cirq_op = _IQM_CIRQ_OP_MAP[instr.name][0]
-    if instr.name == "prx":
-        args = {"exponent": 2 * instr.args["angle_t"], "phase_exponent": 2 * instr.args["phase_t"]}
-    elif instr.name == "measure":
-        args = {"num_qubits": len(qubits), "key": instr.args["key"]}
+        return PhasedXPowGate(**args)(*qubits).with_classical_controls(circuit_operation.args["feedback_key"])
+
+    cirq_op = _IQM_CIRQ_OP_MAP[circuit_operation.name][0]
+    if circuit_operation.name == "prx":
+        args = {
+            "exponent": circuit_operation.args["angle"] / pi,
+            "phase_exponent": circuit_operation.args["phase"] / pi,
+        }
+    elif circuit_operation.name == "measure":
+        args = {"num_qubits": len(qubits), "key": circuit_operation.args["key"]}
         # ignore feedback_key, in Cirq it has to be the same as key
     else:
         # cz, move, reset have no args
@@ -84,7 +93,7 @@ class OperationNotSupportedError(RuntimeError):
     """Raised when a given operation is not supported by the IQM server."""
 
 
-def map_operation(operation: Operation) -> Instruction:
+def operation_to_circuit_operation(operation: Operation) -> CircuitOperation:
     """Map a Cirq Operation to the IQM data transfer format.
 
     Assumes the circuit has been transpiled so that it only contains operations natively supported by the
@@ -94,7 +103,7 @@ def map_operation(operation: Operation) -> Instruction:
         operation: a Cirq Operation
 
     Returns:
-        Instruction: the converted operation
+        CircuitOperation: the converted operation
 
     Raises:
         OperationNotSupportedError When the circuit contains an unsupported operation.
@@ -102,25 +111,25 @@ def map_operation(operation: Operation) -> Instruction:
     """
     locus = tuple(qubit.name if isinstance(qubit, NamedQid) else str(qubit) for qubit in operation.qubits)
     if isinstance(operation.gate, (PhasedXPowGate, XPowGate, YPowGate)):
-        return Instruction(
+        return CircuitOperation(
             name="prx",
-            qubits=locus,
-            args={"angle_t": operation.gate.exponent / 2, "phase_t": operation.gate.phase_exponent / 2},
+            locus=locus,
+            args={"angle": operation.gate.exponent * pi, "phase": operation.gate.phase_exponent * pi},
         )
     if isinstance(operation.gate, MeasurementGate):
         if any(operation.gate.full_invert_mask()):
             raise OperationNotSupportedError("Invert mask not supported")
 
-        return Instruction(
+        return CircuitOperation(
             name="measure",
-            qubits=locus,
+            locus=locus,
             args={"key": operation.gate.key},
         )
     if isinstance(operation.gate, CZPowGate):
         if operation.gate.exponent == 1.0:
-            return Instruction(
+            return CircuitOperation(
                 name="cz",
-                qubits=locus,
+                locus=locus,
                 args={},
             )
         raise OperationNotSupportedError(
@@ -128,14 +137,14 @@ def map_operation(operation: Operation) -> Instruction:
         )
 
     if isinstance(operation.gate, IQMMoveGate):
-        return Instruction(
+        return CircuitOperation(
             name="move",
-            qubits=locus,
+            locus=locus,
             args={},
         )
 
     if isinstance(operation.gate, ResetChannel):
-        return Instruction(name="reset", qubits=locus)
+        return CircuitOperation(name="reset", locus=locus)
 
     if isinstance(operation, ClassicallyControlledOperation):
         if len(operation._conditions) > 1:
@@ -143,12 +152,12 @@ def map_operation(operation: Operation) -> Instruction:
         if not isinstance(operation._conditions[0], KeyCondition):
             raise OperationNotSupportedError("Only KeyConditions are supported as classical controls.")
         if isinstance(operation._sub_operation.gate, (PhasedXPowGate, XPowGate, YPowGate)):
-            return Instruction(
+            return CircuitOperation(
                 name="cc_prx",
-                qubits=locus,
+                locus=locus,
                 args={
-                    "angle_t": operation._sub_operation.gate.exponent / 2,
-                    "phase_t": operation._sub_operation.gate.phase_exponent / 2,
+                    "angle": operation._sub_operation.gate.exponent * pi,
+                    "phase": operation._sub_operation.gate.phase_exponent * pi,
                     "feedback_qubit": "",
                     "feedback_key": str(operation._conditions[0]),
                 },
@@ -162,7 +171,7 @@ def map_operation(operation: Operation) -> Instruction:
     raise OperationNotSupportedError(f"{type(operation.gate)} not natively supported.")
 
 
-def serialize_circuit(circuit: Circuit) -> iqm_client.Circuit:
+def serialize_circuit(circuit: Circuit) -> iqm.pulse.Circuit:
     """Serializes a quantum circuit into the IQM data transfer format.
 
     Args:
@@ -174,10 +183,10 @@ def serialize_circuit(circuit: Circuit) -> iqm_client.Circuit:
     """
     total_ops_list = [op for moment in circuit for op in moment]
     cc_prx_support = any(isinstance(op, ClassicallyControlledOperation) for op in total_ops_list)
-    instructions = list(map(map_operation, total_ops_list))
+    instructions = tuple(map(operation_to_circuit_operation, total_ops_list))
 
     if cc_prx_support:
-        mkey_to_measurement = {}
+        mkey_to_measurement: dict[str, CircuitOperation] = {}
         for inst in instructions:
             if inst.name == "measure":
                 if inst.args["key"] in mkey_to_measurement:
@@ -190,15 +199,15 @@ def serialize_circuit(circuit: Circuit) -> iqm_client.Circuit:
                     raise OperationNotSupportedError(
                         f"cc_prx has feedback_key {feedback_key}, but no measure operation with that key precedes it."
                     )
-                if len(measurement.qubits) != 1:
+                if len(measurement.locus) != 1:
                     raise OperationNotSupportedError("cc_prx must depend on the measurement result of a single qubit.")
-                inst.args["feedback_qubit"] = measurement.qubits[0]
+                inst.args["feedback_qubit"] = measurement.locus[0]
                 measurement.args["feedback_key"] = feedback_key
 
-    return iqm_client.Circuit(name="Serialized from Cirq", instructions=instructions, metadata=None)
+    return iqm.pulse.Circuit(name="Serialized from Cirq", instructions=instructions, metadata=None)
 
 
-def deserialize_circuit(circuit: iqm_client.Circuit) -> Circuit:
+def deserialize_circuit(circuit: iqm.pulse.Circuit) -> Circuit:
     """Deserializes a quantum circuit from the IQM data transfer format to a Cirq Circuit.
 
     Args:
@@ -210,7 +219,7 @@ def deserialize_circuit(circuit: iqm_client.Circuit) -> Circuit:
     """
     return Circuit(
         map(
-            instruction_to_operation,
+            circuit_operation_to_operation,
             circuit.instructions,
         )
     )

iqm/iqm_client/iqm_client.py

@@ -243,7 +243,7 @@ class IQMClient:
                 # validate the circuit against the static information in iqm.iqm_client.models._SUPPORTED_OPERATIONS
                 validate_circuit(circuit)
             except ValueError as e:
-                raise CircuitValidationError(f"The circuit at index {i} failed the validation").with_traceback(
+                raise CircuitValidationError(f"The circuit at index {i} failed the validation: {e}").with_traceback(
                     e.__traceback__
                 )