"""An :class:`Instruction` is the base element for circuits elements, containing
common methods to all of them."""
from __future__ import annotations
from abc import abstractmethod
from copy import deepcopy
from numbers import Complex
from pickle import dumps
from typing import TYPE_CHECKING, Any, Optional
from typeguard import typechecked
if TYPE_CHECKING:
from sympy import Expr
from qiskit.circuit import Parameter
from mpqp.core.languages import Language
from mpqp.tools.generics import SimpleClassReprABC, flatten
[docs]@typechecked
class Instruction(SimpleClassReprABC):
"""Abstract class defining an instruction of a quantum circuit.
An Instruction is the elementary component of a
:class:`QCircuit<mpqp.core.circuit>`. It consists in a manipulation of one
(or several) qubit(s) of the quantum circuit. It may involve classical bits
as well, for defining or retrieving the result of the instruction.
It can be of type:
- :class:`Gate<mpqp.core.instruction.gates.gate.Gate>`
- :class:`Measure<mpqp.core.instruction.measurement.measure.Measure>`
- :class:`Barrier<mpqp.core.instruction.barrier.Barrier>`
Args:
targets: List of indices referring to the qubits on which the
instruction will be applied.
label: Label used to identify the instruction.
"""
def __init__(
self,
targets: list[int],
label: Optional[str] = None,
):
if len(targets) == 0:
raise ValueError("Expected non-empty target list")
if len(set(targets)) != len(targets):
raise ValueError(f"Duplicate registers in targets: {targets}")
if not all([t >= 0 for t in targets]):
raise ValueError(f"Negative index in targets: {targets}")
self.targets = targets
"""See parameter description."""
self.label = label
"""See parameter description."""
@property
def nb_qubits(self) -> int:
"""Number of qubits of this instruction."""
return len(self.connections())
@property
def nb_cbits(self) -> int:
"""Number of cbits of this instruction."""
from mpqp.core.instruction.measurement.basis_measure import BasisMeasure
if isinstance(self, BasisMeasure):
return len(flatten([self.c_targets]))
else:
return 0
[docs] @abstractmethod
def to_other_language(
self,
language: Language = Language.QISKIT,
qiskit_parameters: Optional[set[Parameter]] = None,
) -> Any:
"""Transforms this instruction into the corresponding object in the
language specified in the ``language`` arg.
By default, the instruction is translated to the corresponding one in
Qiskit, since it is the interface we use to generate the OpenQASM code.
In the future, we will generate the OpenQASM code on our own, and this
method will be used only for complex objects that are not tractable by
OpenQASM (like hybrid structures).
Args:
language: Enum representing the target language.
qiskit_parameters: We need to keep track of the parameters
passed to qiskit in order not to define twice the same
parameter. Defaults to ``set()``.
Returns:
The corresponding instruction (gate or measure) in the target
language.
"""
pass
def __eq__(self, value: object) -> bool:
return dumps(self) == dumps(value)
def __str__(self) -> str:
from mpqp.core.circuit import QCircuit
c = QCircuit(max(self.connections()) + 1)
c.add(self)
return str(c)
def __repr__(self) -> str:
from mpqp.core.instruction.gates import ControlledGate
controls = str(self.controls) + "," if isinstance(self, ControlledGate) else ""
return f"{type(self).__name__}({controls}{self.targets})"
[docs] def connections(self) -> set[int]:
"""Returns the indices of the qubits connected to the instruction.
Returns:
The qubits ordered connected to instruction.
Example:
>>> CNOT(0,1).connections()
{0, 1}
"""
from mpqp.core.instruction.gates import ControlledGate
return (
set(self.controls).union(self.targets)
if isinstance(self, ControlledGate)
else set(self.targets)
)
[docs] def subs(
self, values: dict[Expr | str, Complex], remove_symbolic: bool = False
) -> Instruction:
r"""Substitutes the parameters of the instruction with complex values.
Optionally also removes all symbolic variables such as `\pi` (needed for
example for circuit execution).
Since we use ``sympy`` for gates' parameters, ``values`` can in fact be
anything the ``subs`` method from ``sympy`` would accept.
Args:
values: Mapping between the variables and the replacing values.
remove_symbolic: If symbolic values should be replaced by their
numeric counterpart.
Returns:
The circuit with the replaced parameters.
Example:
>>> theta = symbols("θ")
>>> print(Rx(theta, 0).subs({theta: np.pi}))
┌───────┐
q: ┤ Rx(π) ├
└───────┘
"""
return deepcopy(self)