# Copyright 2018-2021 Xanadu Quantum Technologies Inc.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
This module contains functions to load circuits from other frameworks as
PennyLane templates.
"""
from collections.abc import Callable
from importlib import metadata
has_openqasm = True
try:
import openqasm3
from pennylane.io.qasm_interpreter import QasmInterpreter
except (ModuleNotFoundError, ImportError) as import_error: # pragma: no cover
has_openqasm = False # pragma: no cover
# Error message to show when the PennyLane-Qiskit plugin is required but missing.
_MISSING_QISKIT_PLUGIN_MESSAGE = (
"Conversion from Qiskit requires the PennyLane-Qiskit plugin. "
"You can install the plugin by running: pip install pennylane-qiskit. "
"You may need to restart your kernel or environment after installation. "
"If you have any difficulties, you can reach out on the PennyLane forum at "
"https://discuss.pennylane.ai/c/pennylane-plugins/pennylane-qiskit/"
)
# get list of installed plugin converters
__plugin_devices = metadata.entry_points(group="pennylane.io")
plugin_converters = {entry.name: entry for entry in __plugin_devices}
[docs]
def from_qiskit(quantum_circuit, measurements=None):
r"""Converts a Qiskit `QuantumCircuit <https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.QuantumCircuit>`_
into a PennyLane :ref:`quantum function <intro_vcirc_qfunc>`.
.. note::
This function depends upon the PennyLane-Qiskit plugin. Follow the
`installation instructions <https://docs.pennylane.ai/projects/qiskit/en/latest/installation.html>`__
to get up and running. You may need to restart your kernel if you are running in a notebook
environment.
Args:
quantum_circuit (qiskit.QuantumCircuit): a quantum circuit created in Qiskit
measurements (None | MeasurementProcess | list[MeasurementProcess]): an optional PennyLane
measurement or list of PennyLane measurements that overrides any terminal measurements
that may be present in the input circuit
Returns:
function: The PennyLane quantum function, created based on the input Qiskit
``QuantumCircuit`` object.
**Example:**
.. code-block:: python
import pennylane as qp
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 2)
qc.rx(0.785, 0)
qc.ry(1.57, 1)
my_qfunc = qp.from_qiskit(qc)
The ``my_qfunc`` function can now be used within QNodes, as a two-wire quantum
template. We can also pass ``wires`` when calling the returned template to define
which wires it should operate on. If no wires are passed, it will default
to sequential wire labels starting at 0.
.. code-block:: python
dev = qp.device("default.qubit")
@qp.qnode(dev)
def circuit():
my_qfunc(wires=["a", "b"])
return qp.expval(qp.Z("a")), qp.var(qp.Z("b"))
>>> circuit()
(tensor(0.70738827, requires_grad=True),
tensor(0.99999937, requires_grad=True))
The measurements can also be passed directly to the function when creating the
quantum function, making it possible to create a PennyLane circuit with
:class:`qp.QNode <pennylane.QNode>`:
>>> measurements = [qp.expval(qp.Z(0)), qp.var(qp.Z(1))]
>>> circuit = qp.QNode(qp.from_qiskit(qc, measurements), dev)
>>> circuit()
(tensor(0.70738827, requires_grad=True),
tensor(0.99999937, requires_grad=True))
.. note::
The ``measurements`` keyword allows one to add a list of PennyLane measurements
that will **override** any terminal measurements present in the ``QuantumCircuit``,
so that they are not performed before the operations specified in ``measurements``.
``measurements=None``.
If an existing ``QuantumCircuit`` already contains measurements, ``from_qiskit``
will return those measurements, provided that they are not overridden as shown above.
These measurements can be used, e.g., for conditioning with
:func:`qp.cond() <~.cond>`, or simply included directly within the QNode's return:
.. code-block:: python
qc = QuantumCircuit(2, 2)
qc.rx(np.pi, 0)
qc.measure_all()
@qp.qnode(dev)
def circuit():
# Since measurements=None, the measurements present in the QuantumCircuit are returned.
measurements = qp.from_qiskit(qc)()
return [qp.expval(m) for m in measurements]
>>> circuit()
[tensor(1., requires_grad=True), tensor(0., requires_grad=True)]
.. note::
The ``measurements`` returned from a ``QuantumCircuit`` are in the computational basis
with 0 corresponding to :math:`|0\rangle` and 1 corresponding to :math:`|1 \rangle`. This
corresponds to the :math:`|1 \rangle \langle 1|` observable rather than the :math:`Z` Pauli
operator.
See below for more information regarding how to translate more complex circuits from Qiskit to
PennyLane, including handling parametrized Qiskit circuits, mid-circuit measurements, and
classical control flows.
.. details::
:title: Parametrized Quantum Circuits
A Qiskit ``QuantumCircuit`` is parametrized if it contains
`Parameter <https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.Parameter>`__ or
`ParameterVector <https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.ParameterVector>`__
references that need to be given defined values to evaluate the circuit. These can be passed
to the generated quantum function as keyword or positional arguments. If we define a
parametrized circuit:
.. code-block:: python
from qiskit.circuit import QuantumCircuit, Parameter
angle0 = Parameter("x")
angle1 = Parameter("y")
qc = QuantumCircuit(2, 2)
qc.rx(angle0, 0)
qc.ry(angle1, 1)
qc.cx(1, 0)
Then this circuit can be converted into a differentiable circuit in PennyLane and
executed:
.. code-block:: python
import pennylane as qp
from pennylane import numpy as np
dev = qp.device("default.qubit")
qfunc = qp.from_qiskit(qc, measurements=qp.expval(qp.Z(0)))
circuit = qp.QNode(qfunc, dev)
Now, ``circuit`` has a signature of ``(x, y)``. The parameters are ordered alphabetically.
>>> x = np.pi / 4
>>> y = 0
>>> circuit(x, y)
tensor(0.70710678, requires_grad=True)
>>> qp.grad(circuit, argnum=[0, 1])(np.pi/4, np.pi/6)
(array(-0.61237244), array(-0.35355339))
The ``QuantumCircuit`` may also be parametrized with a ``ParameterVector``. These can be
similarly converted:
.. code-block:: python
from qiskit.circuit import ParameterVector
angles = ParameterVector("angles", 2)
qc = QuantumCircuit(2, 2)
qc.rx(angles[0], 0)
qc.ry(angles[1], 1)
qc.cx(1, 0)
@qp.qnode(dev)
def circuit(angles):
qp.from_qiskit(qc)(angles)
return qp.expval(qp.Z(0))
>>> angles = [3.1, 0.45]
>>> circuit(angles)
tensor(-0.89966835, requires_grad=True)
.. details::
:title: Measurements and Classical Control Flows
When ``measurement=None``, all of the measurements performed in the ``QuantumCircuit`` will
be returned by the quantum function in the form of a :ref:`mid-circuit measurement
<mid_circuit_measurements>`. For example, if we define a ``QuantumCircuit`` with
measurements:
.. code-block:: python
import pennylane as qp
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.measure(0, 0)
qc.rz(0.24, [0])
qc.cx(0, 1)
qc.measure_all()
Then we can create a PennyLane circuit that uses this as a sub-circuit, and performs
additional operations conditional on the results. We can also calculate standard mid-circuit
measurement statistics, like expectation value, on the returned measurements:
.. code-block:: python
@qp.qnode(qp.device("default.qubit"))
def circuit():
# apply the QuantumCircuit and retrieve the measurements
mid_measure0, m0, m1 = qp.from_qiskit(qc)()
# conditionally apply an additional operation based on the results
qp.cond(mid_measure0==0, qp.RX)(np.pi/2, 0)
# return the expectation value of one of the mid-circuit measurements, and a terminal measurement
return qp.expval(mid_measure0), qp.expval(m1)
>>> circuit()
(tensor(0.5, requires_grad=True), tensor(0.5, requires_grad=True))
.. note::
The order of mid-circuit measurements returned by `qp.from_qiskit()` in the example
above is determined by the order in which measurements appear in the input Qiskit
``QuantumCircuit``.
Furthermore, the Qiskit `IfElseOp <https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.IfElseOp>`__,
`SwitchCaseOp <https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.SwitchCaseOp>`__ and
`c_if <https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.Instruction#c_if>`__
conditional workflows are automatically translated into their PennyLane counterparts during
conversion. For example, if we construct a ``QuantumCircuit`` with these workflows:
.. code-block:: python
qc = QuantumCircuit(4, 1)
qc.h(0)
qc.measure(0, 0)
# Use an `IfElseOp` operation.
noop = QuantumCircuit(1)
flip_x = QuantumCircuit(1)
flip_x.x(0)
qc.if_else((qc.clbits[0], True), flip_x, noop, [1], [])
# Use a `SwitchCaseOp` operation.
with qc.switch(qc.clbits[0]) as case:
with case(0):
qc.y(2)
# Use the `c_if()` function.
qc.z(3).c_if(qc.clbits[0], True)
qc.measure_all()
We can convert the ``QuantumCircuit`` into a PennyLane quantum function using:
.. code-block:: python
dev = qp.device("default.qubit")
measurements = [qp.expval(qp.Z(i)) for i in range(qc.num_qubits)]
cond_circuit = qp.QNode(qp.from_qiskit(qc, measurements=measurements), dev)
The result is:
>>> print(qp.draw(cond_circuit)())
0: ──H──┤↗├──────────╭||─┤ <Z>
1: ──────║───X───────├||─┤ <Z>
2: ──────║───║──Y────├||─┤ <Z>
3: ──────║───║──║──Z─╰||─┤ <Z>
╚═══╩══╩══╝
"""
try:
plugin_converter = plugin_converters["qiskit"].load()
return plugin_converter(quantum_circuit, measurements=measurements)
except KeyError as e:
raise RuntimeError(_MISSING_QISKIT_PLUGIN_MESSAGE) from e
[docs]
def from_qiskit_op(qiskit_op, params=None, wires=None):
"""Converts a Qiskit `SparsePauliOp <https://docs.quantum.ibm.com/api/qiskit/qiskit.quantum_info.SparsePauliOp>`__
into a PennyLane :class:`Operator <pennylane.operation.Operator>`.
.. note::
This function depends upon the PennyLane-Qiskit plugin. Follow the
`installation instructions <https://docs.pennylane.ai/projects/qiskit/en/latest/installation.html>`__
to get up and running. You may need to restart your kernel if you are running in a notebook
environment.
Args:
qiskit_op (qiskit.quantum_info.SparsePauliOp): a ``SparsePauliOp`` created in Qiskit
params (Any): optional assignment of coefficient values for the ``SparsePauliOp``; see the
`Qiskit documentation <https://docs.quantum.ibm.com/api/qiskit/qiskit.quantum_info.SparsePauliOp#assign_parameters>`_
to learn more about the expected format of these parameters
wires (Sequence | None): optional assignment of wires for the converted ``SparsePauliOp``;
if the original ``SparsePauliOp`` acted on :math:`N` qubits, then this must be a
sequence of length :math:`N`
Returns:
Operator: The PennyLane operator, created based on the input Qiskit
``SparsePauliOp`` object.
.. note::
The wire ordering convention differs between PennyLane and Qiskit: PennyLane wires are
enumerated from left to right, while the Qiskit convention is to enumerate from right to
left. This means a ``SparsePauliOp`` term defined by the string ``"XYZ"`` applies ``Z`` on
wire 0, ``Y`` on wire 1, and ``X`` on wire 2. For more details, see the
`String representation <https://docs.quantum.ibm.com/api/qiskit/qiskit.quantum_info.Pauli>`_
section of the Qiskit documentation for the ``Pauli`` class.
**Example**
Consider the following script which creates a Qiskit ``SparsePauliOp``:
.. code-block:: python
from qiskit.quantum_info import SparsePauliOp
qiskit_op = SparsePauliOp(["II", "XY"])
The ``SparsePauliOp`` contains two terms and acts over two qubits:
>>> qiskit_op
SparsePauliOp(['II', 'XY'],
coeffs=[1.+0.j, 1.+0.j])
To convert the ``SparsePauliOp`` into a PennyLane :class:`pennylane.operation.Operator`, use:
>>> import pennylane as qp
>>> qp.from_qiskit_op(qiskit_op)
I(0) + X(1) @ Y(0)
.. details::
:title: Usage Details
You can convert a parametrized ``SparsePauliOp`` into a PennyLane operator by assigning
literal values to each coefficient parameter. For example, the script
.. code-block:: python
import numpy as np
from qiskit.circuit import Parameter
a, b, c = [Parameter(var) for var in "abc"]
param_qiskit_op = SparsePauliOp(["II", "XZ", "YX"], coeffs=np.array([a, b, c]))
defines a ``SparsePauliOp`` with three coefficients (parameters):
>>> param_qiskit_op
SparsePauliOp(['II', 'XZ', 'YX'],
coeffs=[ParameterExpression(1.0*a), ParameterExpression(1.0*b),
ParameterExpression(1.0*c)])
The ``SparsePauliOp`` can be converted into a PennyLane operator by calling the conversion
function and specifying the value of each parameter using the ``params`` argument:
>>> qp.from_qiskit_op(param_qiskit_op, params={a: 2, b: 3, c: 4})
(
(2+0j) * I(0)
+ (3+0j) * (X(1) @ Z(0))
+ (4+0j) * (Y(1) @ X(0))
)
Similarly, a custom wire mapping can be applied to a ``SparsePauliOp`` as follows:
>>> wired_qiskit_op = SparsePauliOp("XYZ")
>>> wired_qiskit_op
SparsePauliOp(['XYZ'],
coeffs=[1.+0.j])
>>> qp.from_qiskit_op(wired_qiskit_op, wires=[3, 5, 7])
Y(5) @ Z(3) @ X(7)
"""
try:
plugin_converter = plugin_converters["qiskit_op"].load()
return plugin_converter(qiskit_op, params=params, wires=wires)
except KeyError as e:
raise RuntimeError(_MISSING_QISKIT_PLUGIN_MESSAGE) from e
[docs]
def from_qiskit_noise(noise_model, verbose=False, decimal_places=None):
"""Converts a Qiskit `NoiseModel <https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.noise.NoiseModel.html>`__
into a PennyLane :class:`~.NoiseModel`.
Args:
noise_model (qiskit_aer.noise.NoiseModel): a Qiskit ``NoiseModel`` instance.
verbose (bool): when printing a ``NoiseModel``, a complete list of Kraus matrices for each ``qp.QubitChannel``
is displayed with ``verbose=True``. By default, ``verbose=False`` and only the number of Kraus matrices and
the number of qubits they act on is displayed for brevity.
decimal_places (int | None): number of decimal places to round the elements of Kraus matrices when they are being
displayed for each ``qp.QubitChannel`` when ``verbose=True``.
Returns:
qp.NoiseModel: The PennyLane noise model converted from the input Qiskit ``NoiseModel`` object.
Raises:
ValueError: When a quantum error present in the noise model cannot be converted.
.. note::
- This function depends upon the PennyLane-Qiskit plugin, which can be installed following these
`installation instructions <https://docs.pennylane.ai/projects/qiskit/en/latest/installation.html>`__.
You may need to restart your kernel if you are running it in a notebook environment.
- Each quantum error present in the qiskit noise model is converted into an equivalent
:class:`~.QubitChannel` operator with the same canonical Kraus representation.
- Currently, PennyLane noise models do not support readout errors, so those will be skipped during
conversion.
**Example**
Consider the following noise model constructed in Qiskit:
>>> import qiskit_aer.noise as noise
>>> error_1 = noise.depolarizing_error(0.001, 1) # 1-qubit noise
>>> error_2 = noise.depolarizing_error(0.01, 2) # 2-qubit noise
>>> noise_model = noise.NoiseModel()
>>> noise_model.add_all_qubit_quantum_error(error_1, ['rz', 'ry'])
>>> noise_model.add_all_qubit_quantum_error(error_2, ['cx'])
This noise model can be converted into PennyLane using:
>>> import pennylane as qp
>>> qp.from_qiskit_noise(noise_model)
NoiseModel({
OpIn(['RZ', 'RY']): QubitChannel(num_kraus=4, num_wires=1)
OpIn(['CNOT']): QubitChannel(num_kraus=16, num_wires=2)
})
"""
try:
plugin_converter = plugin_converters["qiskit_noise"].load()
return plugin_converter(noise_model, verbose=verbose, decimal_places=decimal_places)
except KeyError as e:
raise RuntimeError(_MISSING_QISKIT_PLUGIN_MESSAGE) from e
[docs]
def from_qasm(quantum_circuit: str, measurements=None):
r"""
Loads quantum circuits from a QASM string using the converter in the
PennyLane-Qiskit plugin.
.. warning::
``from_qasm`` returns a **quantum function** that must be called.
.. code-block:: python
# INCORRECT: no operations will end up in the circuit
@qp.qnode(dev)
def circuit_from_qasm():
qp.from_qasm(qasm_string)
return qp.probs()
# CORRECT: from_qasm is called
@qp.qnode(dev)
def circuit_from_qasm():
qp.from_qasm(qasm_string)()
return qp.probs()
Args:
quantum_circuit (str): a QASM string containing a valid quantum circuit
measurements (None | MeasurementProcess | list[MeasurementProcess]): an optional PennyLane
measurement or list of PennyLane measurements that overrides the terminal measurements
that may be present in the input circuit. Defaults to ``None``, such that all existing measurements
in the input circuit are returned. See *Removing terminal measurements* for details.
Returns:
function: the PennyLane quantum function created based on the QASM string. This function itself returns the
mid-circuit measurements plus the terminal measurements by default (``measurements=None``),
and returns **only** the measurements from the ``measurements`` argument otherwise.
.. seealso:: :func:`~.from_qasm3`, which relies on the ``openqasm3`` and ``openqasm3[parser]`` packages
instead of ``pennylane-qiskit``, and supports newer syntax features.
**Example:**
.. code-block:: python
qasm_code = 'OPENQASM 2.0;' \
'include "qelib1.inc";' \
'qreg q[2];' \
'creg c[2];' \
'h q[0];' \
'measure q[0] -> c[0];' \
'rz(0.24) q[0];' \
'cx q[0], q[1];' \
'measure q -> c;'
loaded_circuit = qp.from_qasm(qasm_code)
>>> print(qp.draw(loaded_circuit)())
0: ──H──┤↗├──RZ(0.24)─╭●──┤↗├─┤
1: ───────────────────╰X──┤↗├─┤
Calling the quantum function returns a tuple containing the mid-circuit measurements and the terminal measurements.
>>> loaded_circuit()
(MeasurementValue(wires=[0]),
MeasurementValue(wires=[0]),
MeasurementValue(wires=[1]))
A list of measurements can also be passed directly to ``from_qasm`` using the ``measurements`` argument, making
it possible to create a PennyLane circuit with :class:`qp.QNode <pennylane.QNode>`.
.. code-block:: python
dev = qp.device("default.qubit")
measurements = [qp.var(qp.Y(0))]
circuit = qp.QNode(qp.from_qasm(qasm_code, measurements = measurements), dev)
>>> print(qp.draw(circuit)())
0: ──H──┤↗├──RZ(0.24)─╭●─┤ Var[Y]
1: ───────────────────╰X─┤
.. details::
:title: Removing terminal measurements
To remove all terminal measurements, set ``measurements=[]``. This removes the existing terminal
measurements and keeps the mid-circuit measurements.
.. code-block:: python
loaded_circuit = qp.from_qasm(qasm_code, measurements=[])
>>> print(qp.draw(loaded_circuit)())
0: ──H──┤↗├──RZ(0.24)─╭●─┤
1: ───────────────────╰X─┤
Calling the quantum function returns the same empty list that we originally passed in.
>>> loaded_circuit()
[]
Note that mid-circuit measurements are always applied, but are only returned when
``measurements=None``. This can be exemplified by using the ``loaded_circuit``
without the terminal measurements within a ``QNode``.
.. code-block:: python
dev = qp.device("default.qubit")
@qp.qnode(dev)
def circuit():
loaded_circuit()
return qp.expval(qp.Z(1))
>>> print(qp.draw(circuit)())
0: ──H──┤↗├──RZ(0.24)─╭●─┤
1: ───────────────────╰X─┤ <Z>
.. details::
:title: Using conditional operations
We can take advantage of the mid-circuit measurements inside the QASM code by
calling the returned function within a :class:`qp.QNode <pennylane.QNode>`.
.. code-block:: python
loaded_circuit = qp.from_qasm(qasm_code)
@qp.qnode(dev)
def circuit():
mid_measure, *_ = loaded_circuit()
qp.cond(mid_measure == 0, qp.RX)(np.pi / 2, 0)
return [qp.expval(qp.Z(0))]
>>> print(qp.draw(circuit)())
0: ──H──┤↗├──RZ(0.24)─╭●──┤↗├──RX(1.57)─┤ <Z>
1: ──────║────────────╰X──┤↗├──║────────┤
╚═════════════════════╝
.. details::
:title: Importing from a QASM file
We can also load the contents of a QASM file.
.. code-block:: python
# save the qasm code in a file
import locale
from pathlib import Path
filename = "circuit.qasm"
with Path(filename).open("w", encoding=locale.getpreferredencoding(False)) as f:
f.write(qasm_code)
with open("circuit.qasm", "r") as f:
loaded_circuit = qp.from_qasm(f.read())
The ``loaded_circuit`` function can now be used within a
:class:`qp.QNode <pennylane.QNode>` as a two-wire quantum template.
.. code-block:: python
@qp.qnode(dev)
def circuit(x):
qp.RX(x, wires=1)
loaded_circuit(wires=(0, 1))
return qp.expval(qp.Z(0))
>>> print(qp.draw(circuit)(1.23))
0: ──H─────────┤↗├──RZ(0.24)─╭●──┤↗├─┤ <Z>
1: ──RX(1.23)────────────────╰X──┤↗├─┤
"""
try:
plugin_converter = plugin_converters["qasm"].load()
except Exception as e: # pragma: no cover
raise RuntimeError( # pragma: no cover
"Failed to load the qasm plugin. Please ensure that the pennylane-qiskit package is installed."
) from e
return plugin_converter(quantum_circuit, measurements=measurements)
[docs]
def from_qasm3(quantum_circuit: str, wire_map: dict | None = None) -> Callable:
"""
Converts an OpenQASM 3.0 circuit into a quantum function that can be used within a QNode.
.. note::
The standard library gates, qubit registers, built-in mathematical functions and constants, subroutines,
variables, control flow, measurements, inputs, outputs, custom gates and ``end`` statements are all supported.
Pulses are not yet supported.
In order to use this function, ``openqasm3`` and ``'openqasm3[parser]'`` must be installed in the user's
environment. Please consult the `OpenQASM installation instructions <https://pypi.org/project/openqasm3>`__
for directions.
Args:
quantum_circuit (str): a QASM 3.0 string containing a simple quantum circuit.
wire_map (Optional[dict]): the mapping from OpenQASM 3.0 qubit names to PennyLane wires.
Returns:
Callable: A quantum function that will execute the program.
**Examples**
First, we define a QASM 3.0 circuit as a string. In this example, we define three qubits,
a few parameterized gates, a subroutine with a measurement, and a control flow statement.
.. code-block:: python
qasm_string = '''
qubit q0;
qubit q1;
qubit q2;
float theta = 0.2;
int power = 2;
ry(theta / 2) q0;
rx(theta) q1;
pow(power) @ x q0;
def random(qubit q) -> bit
{
bit b = "0";
h q;
measure q -> b;
return b;
}
bit m = random(q2);
if (m) {
int i = 0;
while (i < 5) {
i = i + 1;
rz(i) q1;
break;
}
}
'''
We can convert this circuit into a PennyLane quantum function using:
.. code-block:: python
@qp.qnode(qp.device("default.qubit", wires=[0, 1, 2]))
def my_circuit():
qp.from_qasm3(
qasm_string,
{'q0': 0, 'q1': 1, 'q2': 2}
)()
return qp.expval(qp.Z(0))
Inspecting the circuit, we can see that the operations and measurements have been correctly interpreted.
>>> print(qp.draw(my_circuit)())
0: ──RY(0.10)──X²────────────┤ <Z>
1: ──RX(0.20)───────RZ(1.00)─┤
2: ──H─────────┤↗├──║────────┤
╚═══╝
"""
if not has_openqasm: # pragma: no cover
raise ImportWarning(
"from_qasm3 requires openqasm3 and 'openqasm3[parser]' to be installed in your environment. "
"Please consult the OpenQASM 3.0 installation instructions for more information:"
" https://pypi.org/project/openqasm3/."
) # pragma: no cover
# parse the QASM program
try:
ast = openqasm3.parser.parse(quantum_circuit, permissive=True)
except AttributeError as e: # pragma: no cover
raise ImportError(
"antlr4-python3-runtime is required to interpret openqasm3 in addition to the openqasm3 package"
) from e # pragma: no cover
except Exception as e:
raise SyntaxError(
f"Something went wrong when parsing the provided OpenQASM 3.0 code. "
f"Please ensure the code is valid OpenQASM 3.0 syntax. {str(e)}",
) from e
def interpret_function(**kwargs):
context = QasmInterpreter().interpret(
ast, context={"name": "global", "wire_map": wire_map}, **kwargs
)
if context["return"]:
return tuple(map(lambda v: v.val, context["return"].values()))
return context
return interpret_function