9405162251

Committed 06 Jun 2024 05:08PM UTC coverage: 89.629% (-0.005%) from 89.634%

Build # 9405162251

Build Type

push

github

Committed by

web-flow

Commit Message

Implement `__array__` for `qasm2._DefinedGate` (#12119) (#12523)

* Implement `__array__` for `qasm2._DefinedGate`

Gates defined from OpenQASM 2 should have a well-defined matrix form (up
to global phase) whenever all the constituent parts of the definition
do. This manually makes such a matrix available.

* Fix signature for Numpy 2.0

(cherry picked from commit 767bd0733)

Co-authored-by: Jake Lishman <jake.lishman@ibm.com>

Run Details

5 of 6 new or added lines in 1 file covered. (83.33%)

13 existing lines in 3 files now uncovered.

62259 of 69463 relevant lines covered (89.63%)

231547.63 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.7

/qiskit/qasm2/parse.py

# This code is part of Qiskit.
#
# (C) Copyright IBM 2023.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.

"""Python-space bytecode interpreter for the output of the main Rust parser logic."""

import dataclasses
import math
from typing import Iterable, Callable

import numpy as np

from qiskit.circuit import (
    Barrier,
    CircuitInstruction,
    ClassicalRegister,
    Delay,
    Gate,
    Instruction,
    Measure,
    QuantumCircuit,
    QuantumRegister,
    Qubit,
    Reset,
    library as lib,
)
from qiskit.quantum_info import Operator
from qiskit._accelerate.qasm2 import (
    OpCode,
    UnaryOpCode,
    BinaryOpCode,
    CustomClassical,
    ExprConstant,
    ExprArgument,
    ExprUnary,
    ExprBinary,
    ExprCustom,
)
from .exceptions import QASM2ParseError

# Constructors of the form `*params -> Gate` for the special 'qelib1.inc' include.  This is
# essentially a pre-parsed state for the file as given in the arXiv paper defining OQ2.
QELIB1 = (
    lib.U3Gate,
    lib.U2Gate,
    lib.U1Gate,
    lib.CXGate,
    # IGate in Terra < 0.24 is defined as a single-cycle delay, so is not strictly an identity.
    # Instead we use a true no-op stand-in.
    lambda: lib.UGate(0, 0, 0),
    lib.XGate,
    lib.YGate,
    lib.ZGate,
    lib.HGate,
    lib.SGate,
    lib.SdgGate,
    lib.TGate,
    lib.TdgGate,
    lib.RXGate,
    lib.RYGate,
    lib.RZGate,
    lib.CZGate,
    lib.CYGate,
    lib.CHGate,
    lib.CCXGate,
    lib.CRZGate,
    lib.CU1Gate,
    lib.CU3Gate,
)


@dataclasses.dataclass(frozen=True)
class CustomInstruction:
    """Information about a custom instruction that should be defined during the parse.

    The ``name``, ``num_params`` and ``num_qubits`` fields are self-explanatory.  The
    ``constructor`` field should be a callable object with signature ``*args -> Instruction``, where
    each of the ``num_params`` ``args`` is a floating-point value.  Most of the built-in Qiskit gate
    classes have this form.

    There is a final ``builtin`` field.  This is optional, and if set true will cause the
    instruction to be defined and available within the parsing, even if there is no definition in
    any included OpenQASM 2 file.
    """

    name: str
    num_params: int
    num_qubits: int
    # This should be `(float*) -> Instruction`, but the older version of Sphinx we're constrained to
    # use in the Python 3.9 docs build chokes on it, so relax the hint.
    constructor: Callable[..., Instruction]
    builtin: bool = False


def _generate_delay(time: float):
    # This wrapper is just to ensure that the correct type of exception gets emitted; it would be
    # unnecessarily spaghetti-ish to check every emitted instruction in Rust for integer
    # compatibility, but only if its name is `delay` _and_ its constructor wraps Qiskit's `Delay`.
    if int(time) != time:
        raise QASM2ParseError("the custom 'delay' instruction can only accept an integer parameter")
    return Delay(int(time), unit="dt")


class _U0Gate(Gate):
    def __init__(self, count):
        if int(count) != count:
            raise QASM2ParseError("the number of single-qubit delay lengths must be an integer")
        super().__init__("u0", 1, [int(count)])

    def _define(self):
        self._definition = QuantumCircuit(1)
        for _ in [None] * self.params[0]:
            self._definition.id(0)


LEGACY_CUSTOM_INSTRUCTIONS = (
    CustomInstruction("u3", 3, 1, lib.U3Gate),
    CustomInstruction("u2", 2, 1, lib.U2Gate),
    CustomInstruction("u1", 1, 1, lib.U1Gate),
    CustomInstruction("cx", 0, 2, lib.CXGate),
    # The Qiskit parser emits IGate for 'id', even if that is not strictly accurate in Terra < 0.24.
    CustomInstruction("id", 0, 1, lib.IGate),
    CustomInstruction("u0", 1, 1, _U0Gate, builtin=True),
    CustomInstruction("u", 3, 1, lib.UGate, builtin=True),
    CustomInstruction("p", 1, 1, lib.PhaseGate, builtin=True),
    CustomInstruction("x", 0, 1, lib.XGate),
    CustomInstruction("y", 0, 1, lib.YGate),
    CustomInstruction("z", 0, 1, lib.ZGate),
    CustomInstruction("h", 0, 1, lib.HGate),
    CustomInstruction("s", 0, 1, lib.SGate),
    CustomInstruction("sdg", 0, 1, lib.SdgGate),
    CustomInstruction("t", 0, 1, lib.TGate),
    CustomInstruction("tdg", 0, 1, lib.TdgGate),
    CustomInstruction("rx", 1, 1, lib.RXGate),
    CustomInstruction("ry", 1, 1, lib.RYGate),
    CustomInstruction("rz", 1, 1, lib.RZGate),
    CustomInstruction("sx", 0, 1, lib.SXGate, builtin=True),
    CustomInstruction("sxdg", 0, 1, lib.SXdgGate, builtin=True),
    CustomInstruction("cz", 0, 2, lib.CZGate),
    CustomInstruction("cy", 0, 2, lib.CYGate),
    CustomInstruction("swap", 0, 2, lib.SwapGate, builtin=True),
    CustomInstruction("ch", 0, 2, lib.CHGate),
    CustomInstruction("ccx", 0, 3, lib.CCXGate),
    CustomInstruction("cswap", 0, 3, lib.CSwapGate, builtin=True),
    CustomInstruction("crx", 1, 2, lib.CRXGate, builtin=True),
    CustomInstruction("cry", 1, 2, lib.CRYGate, builtin=True),
    CustomInstruction("crz", 1, 2, lib.CRZGate),
    CustomInstruction("cu1", 1, 2, lib.CU1Gate),
    CustomInstruction("cp", 1, 2, lib.CPhaseGate, builtin=True),
    CustomInstruction("cu3", 3, 2, lib.CU3Gate),
    CustomInstruction("csx", 0, 2, lib.CSXGate, builtin=True),
    CustomInstruction("cu", 4, 2, lib.CUGate, builtin=True),
    CustomInstruction("rxx", 1, 2, lib.RXXGate, builtin=True),
    CustomInstruction("rzz", 1, 2, lib.RZZGate, builtin=True),
    CustomInstruction("rccx", 0, 3, lib.RCCXGate, builtin=True),
    CustomInstruction("rc3x", 0, 4, lib.RC3XGate, builtin=True),
    CustomInstruction("c3x", 0, 4, lib.C3XGate, builtin=True),
    CustomInstruction("c3sqrtx", 0, 4, lib.C3SXGate, builtin=True),
    CustomInstruction("c4x", 0, 5, lib.C4XGate, builtin=True),
    CustomInstruction("delay", 1, 1, _generate_delay),
)

LEGACY_CUSTOM_CLASSICAL = (
    CustomClassical("asin", 1, math.asin),
    CustomClassical("acos", 1, math.acos),
    CustomClassical("atan", 1, math.atan),
)


def from_bytecode(bytecode, custom_instructions: Iterable[CustomInstruction]):
    """Loop through the Rust bytecode iterator `bytecode` producing a
    :class:`~qiskit.circuit.QuantumCircuit` instance from it.  All the hard work is done in Rust
    space where operations are faster; here, we're just about looping through the instructions as
    fast as possible, doing as little calculation as we can in Python space.  The Python-space
    components are the vast majority of the runtime.

    The "bytecode", and so also this Python function, is very tightly coupled to the output of the
    Rust parser.  The bytecode itself is largely defined by Rust; from Python space, the iterator is
    over essentially a 2-tuple of `(opcode, operands)`.  The `operands` are fixed by Rust, and
    assumed to be correct by this function.

    The Rust code is responsible for all validation.  If this function causes any errors to be
    raised by Qiskit (except perhaps for some symbolic manipulations of `Parameter` objects), we
    should consider that a bug in the Rust code."""
    # The method `QuantumCircuit._append` is a semi-public method, so isn't really subject to
    # "protected access".
    # pylint: disable=protected-access
    qc = QuantumCircuit()
    qubits = []
    clbits = []
    gates = []
    has_u, has_cx = False, False
    for custom in custom_instructions:
        gates.append(custom.constructor)
        if custom.name == "U":
            has_u = True
        elif custom.name == "CX":
            has_cx = True
    if not has_u:
        gates.append(lib.UGate)
    if not has_cx:
        gates.append(lib.CXGate)
    # Pull this out as an explicit iterator so we can manually advance the loop in `DeclareGate`
    # contexts easily.
    bc = iter(bytecode)
    for op in bc:
        # We have to check `op.opcode` so many times, it's worth pulling out the extra attribute
        # access.  We should check the opcodes in order of their likelihood to be in the OQ2 program
        # for speed.  Gate applications are by far the most common for long programs.  This function
        # is deliberately long and does not use hashmaps or function lookups for speed in
        # Python-space.
        opcode = op.opcode
        # `OpCode` is an `enum` in Rust, but its instances don't have the same singleton property as
        # Python `enum.Enum` objects.
        if opcode == OpCode.Gate:
            gate_id, parameters, op_qubits = op.operands
            qc._append(
                CircuitInstruction(gates[gate_id](*parameters), [qubits[q] for q in op_qubits])
            )
        elif opcode == OpCode.ConditionedGate:
            gate_id, parameters, op_qubits, creg, value = op.operands
            gate = gates[gate_id](*parameters).c_if(qc.cregs[creg], value)
            qc._append(CircuitInstruction(gate, [qubits[q] for q in op_qubits]))
        elif opcode == OpCode.Measure:
            qubit, clbit = op.operands
            qc._append(CircuitInstruction(Measure(), (qubits[qubit],), (clbits[clbit],)))
        elif opcode == OpCode.ConditionedMeasure:
            qubit, clbit, creg, value = op.operands
            measure = Measure().c_if(qc.cregs[creg], value)
            qc._append(CircuitInstruction(measure, (qubits[qubit],), (clbits[clbit],)))
        elif opcode == OpCode.Reset:
            qc._append(CircuitInstruction(Reset(), (qubits[op.operands[0]],)))
        elif opcode == OpCode.ConditionedReset:
            qubit, creg, value = op.operands
            reset = Reset().c_if(qc.cregs[creg], value)
            qc._append(CircuitInstruction(reset, (qubits[qubit],)))
        elif opcode == OpCode.Barrier:
            op_qubits = op.operands[0]
            qc._append(CircuitInstruction(Barrier(len(op_qubits)), [qubits[q] for q in op_qubits]))
        elif opcode == OpCode.DeclareQreg:
            name, size = op.operands
            register = QuantumRegister(size, name)
            qubits += register[:]
            qc.add_register(register)
        elif opcode == OpCode.DeclareCreg:
            name, size = op.operands
            register = ClassicalRegister(size, name)
            clbits += register[:]
            qc.add_register(register)
        elif opcode == OpCode.SpecialInclude:
            # Including `qelib1.inc` is pretty much universal, and we treat its gates as having
            # special relationships to the Qiskit ones, so we don't actually parse it; we just
            # short-circuit to add its pre-calculated content to our state.
            (indices,) = op.operands
            for index in indices:
                gates.append(QELIB1[index])
        elif opcode == OpCode.DeclareGate:
            name, num_qubits = op.operands
            # This inner loop advances the iterator of the outer loop as well, since `bc` is a
            # manually created iterator, rather than an implicit one from the first loop.
            inner_bc = []
            for inner_op in bc:
                if inner_op.opcode == OpCode.EndDeclareGate:
                    break
                inner_bc.append(inner_op)
            # Technically there's a quadratic dependency in the number of gates here, which could be
            # fixed by just sharing a reference to `gates` rather than recreating a new object.
            # Gates can't ever be removed from the list, so it wouldn't get out-of-date, though
            # there's a minor risk of somewhere accidentally mutating it instead, and in practice
            # the cost shouldn't really matter.
            gates.append(_gate_builder(name, num_qubits, tuple(gates), inner_bc))
        elif opcode == OpCode.DeclareOpaque:
            name, num_qubits = op.operands
            gates.append(_opaque_builder(name, num_qubits))
        else:
            raise ValueError(f"invalid operation: {op}")
    return qc


class _DefinedGate(Gate):
    """A gate object defined by a `gate` statement in an OpenQASM 2 program.  This object lazily
    binds its parameters to its definition, so it is only synthesised when required."""

    def __init__(self, name, num_qubits, params, gates, bytecode):
        self._gates = gates
        self._bytecode = bytecode
        super().__init__(name, num_qubits, list(params))

    def _define(self):
        # This is a stripped-down version of the bytecode interpreter; there's very few opcodes that
        # we actually need to handle within gate bodies.
        # pylint: disable=protected-access
        qubits = [Qubit() for _ in [None] * self.num_qubits]
        qc = QuantumCircuit(qubits)
        for op in self._bytecode:
            if op.opcode == OpCode.Gate:
                gate_id, args, op_qubits = op.operands
                qc._append(
                    CircuitInstruction(
                        self._gates[gate_id](*(_evaluate_argument(a, self.params) for a in args)),
                        [qubits[q] for q in op_qubits],
                    )
                )
            elif op.opcode == OpCode.Barrier:
                op_qubits = op.operands[0]
                qc._append(
                    CircuitInstruction(Barrier(len(op_qubits)), [qubits[q] for q in op_qubits])
                )
            else:
                raise ValueError(f"received invalid bytecode to build gate: {op}")
        self._definition = qc

    def __array__(self, dtype=None, copy=None):
        if copy is False:
            raise ValueError("unable to avoid copy while creating an array as requested")
        return np.asarray(Operator(self.definition), dtype=dtype)

    # It's fiddly to implement pickling for PyO3 types (the bytecode stream), so instead if we need
    # to pickle ourselves, we just eagerly create the definition and pickle that.

    def __getstate__(self):
        return (self.name, self.num_qubits, self.params, self.definition, self.condition)

    def __setstate__(self, state):
        name, num_qubits, params, definition, condition = state
        super().__init__(name, num_qubits, params)
        self._gates = ()
        self._bytecode = ()
        self._definition = definition
        self._condition = condition


def _gate_builder(name, num_qubits, known_gates, bytecode):
    """Create a gate-builder function of the signature `*params -> Gate` for a gate with a given
    `name`.  This produces a `_DefinedGate` class, whose `_define` method runs through the given
    `bytecode` using the current list of `known_gates` to interpret the gate indices.

    The indirection here is mostly needed to correctly close over `known_gates` and `bytecode`."""

    def definer(*params):
        return _DefinedGate(name, num_qubits, params, known_gates, tuple(bytecode))

    return definer


def _opaque_builder(name, num_qubits):
    """Create a gate-builder function of the signature `*params -> Gate` for an opaque gate with a
    given `name`, which takes the given numbers of qubits."""

    def definer(*params):
        return Gate(name, num_qubits, params)

    return definer


# The natural way to reduce returns in this function would be to use a lookup table for the opcodes,
# but the PyO3 enum entities aren't (currently) hashable.
def _evaluate_argument(expr, parameters):  # pylint: disable=too-many-return-statements
    """Inner recursive function to calculate the value of a mathematical expression given the
    concrete values in the `parameters` field."""
    if isinstance(expr, ExprConstant):
        return expr.value
    if isinstance(expr, ExprArgument):
        return parameters[expr.index]
    if isinstance(expr, ExprUnary):
        inner = _evaluate_argument(expr.argument, parameters)
        opcode = expr.opcode
        if opcode == UnaryOpCode.Negate:
            return -inner
        if opcode == UnaryOpCode.Cos:
            return math.cos(inner)
        if opcode == UnaryOpCode.Exp:
            return math.exp(inner)
        if opcode == UnaryOpCode.Ln:
            return math.log(inner)
        if opcode == UnaryOpCode.Sin:
            return math.sin(inner)
        if opcode == UnaryOpCode.Sqrt:
            return math.sqrt(inner)
        if opcode == UnaryOpCode.Tan:
            return math.tan(inner)
        raise ValueError(f"unhandled unary opcode: {opcode}")
    if isinstance(expr, ExprBinary):
        left = _evaluate_argument(expr.left, parameters)
        right = _evaluate_argument(expr.right, parameters)
        opcode = expr.opcode
        if opcode == BinaryOpCode.Add:
            return left + right
        if opcode == BinaryOpCode.Subtract:
            return left - right
        if opcode == BinaryOpCode.Multiply:
            return left * right
        if opcode == BinaryOpCode.Divide:
            return left / right
        if opcode == BinaryOpCode.Power:
            return left**right
        raise ValueError(f"unhandled binary opcode: {opcode}")
    if isinstance(expr, ExprCustom):
        return expr.callable(*(_evaluate_argument(x, parameters) for x in expr.arguments))
    raise ValueError(f"unhandled expression type: {expr}")

1	# This code is part of Qiskit.
2	#
3	# (C) Copyright IBM 2023.
4	#
5	# This code is licensed under the Apache License, Version 2.0. You may
6	# obtain a copy of this license in the LICENSE.txt file in the root directory
7	# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
8	#
9	# Any modifications or derivative works of this code must retain this
10	# copyright notice, and modified files need to carry a notice indicating
11	# that they have been altered from the originals.
12
13	"""Python-space bytecode interpreter for the output of the main Rust parser logic."""	1✔
14
15	import dataclasses	1✔
16	import math	1✔
17	from typing import Iterable, Callable	1✔
18
19	import numpy as np	1✔
20
21	from qiskit.circuit import (	1✔
22	Barrier,
23	CircuitInstruction,
24	ClassicalRegister,
25	Delay,
26	Gate,
27	Instruction,
28	Measure,
29	QuantumCircuit,
30	QuantumRegister,
31	Qubit,
32	Reset,
33	library as lib,
34	)
35	from qiskit.quantum_info import Operator	1✔
36	from qiskit._accelerate.qasm2 import (	1✔
37	OpCode,
38	UnaryOpCode,
39	BinaryOpCode,
40	CustomClassical,
41	ExprConstant,
42	ExprArgument,
43	ExprUnary,
44	ExprBinary,
45	ExprCustom,
46	)
47	from .exceptions import QASM2ParseError	1✔
48
49	# Constructors of the form `*params -> Gate` for the special 'qelib1.inc' include. This is
50	# essentially a pre-parsed state for the file as given in the arXiv paper defining OQ2.
51	QELIB1 = (	1✔
52	lib.U3Gate,
53	lib.U2Gate,
54	lib.U1Gate,
55	lib.CXGate,
56	# IGate in Terra < 0.24 is defined as a single-cycle delay, so is not strictly an identity.
57	# Instead we use a true no-op stand-in.
58	lambda: lib.UGate(0, 0, 0),
59	lib.XGate,
60	lib.YGate,
61	lib.ZGate,
62	lib.HGate,
63	lib.SGate,
64	lib.SdgGate,
65	lib.TGate,
66	lib.TdgGate,
67	lib.RXGate,
68	lib.RYGate,
69	lib.RZGate,
70	lib.CZGate,
71	lib.CYGate,
72	lib.CHGate,
73	lib.CCXGate,
74	lib.CRZGate,
75	lib.CU1Gate,
76	lib.CU3Gate,
77	)
78
79
80	@dataclasses.dataclass(frozen=True)	1✔
81	class CustomInstruction:	1✔
82	"""Information about a custom instruction that should be defined during the parse.	1✔
83
84	The ``name``, ``num_params`` and ``num_qubits`` fields are self-explanatory. The
85	``constructor`` field should be a callable object with signature ``*args -> Instruction``, where
86	each of the ``num_params`` ``args`` is a floating-point value. Most of the built-in Qiskit gate
87	classes have this form.
88
89	There is a final ``builtin`` field. This is optional, and if set true will cause the
90	instruction to be defined and available within the parsing, even if there is no definition in
91	any included OpenQASM 2 file.
92	"""
93
94	name: str	1✔
95	num_params: int	1✔
96	num_qubits: int	1✔
97	# This should be `(float*) -> Instruction`, but the older version of Sphinx we're constrained to
98	# use in the Python 3.9 docs build chokes on it, so relax the hint.
99	constructor: Callable[..., Instruction]	1✔
100	builtin: bool = False	1✔
101
102
103	def _generate_delay(time: float):	1✔
104	# This wrapper is just to ensure that the correct type of exception gets emitted; it would be
105	# unnecessarily spaghetti-ish to check every emitted instruction in Rust for integer
106	# compatibility, but only if its name is `delay` _and_ its constructor wraps Qiskit's `Delay`.
107	if int(time) != time:	1✔
108	raise QASM2ParseError("the custom 'delay' instruction can only accept an integer parameter")	1✔
109	return Delay(int(time), unit="dt")	1✔
110
111
112	class _U0Gate(Gate):	1✔
113	def __init__(self, count):	1✔
114	if int(count) != count:	1✔
115	raise QASM2ParseError("the number of single-qubit delay lengths must be an integer")	1✔
116	super().__init__("u0", 1, [int(count)])	1✔
117
118	def _define(self):	1✔
119	self._definition = QuantumCircuit(1)	1✔
120	for _ in [None] * self.params[0]:	1✔
121	self._definition.id(0)	1✔
122
123
124	LEGACY_CUSTOM_INSTRUCTIONS = (	1✔
125	CustomInstruction("u3", 3, 1, lib.U3Gate),
126	CustomInstruction("u2", 2, 1, lib.U2Gate),
127	CustomInstruction("u1", 1, 1, lib.U1Gate),
128	CustomInstruction("cx", 0, 2, lib.CXGate),
129	# The Qiskit parser emits IGate for 'id', even if that is not strictly accurate in Terra < 0.24.
130	CustomInstruction("id", 0, 1, lib.IGate),
131	CustomInstruction("u0", 1, 1, _U0Gate, builtin=True),
132	CustomInstruction("u", 3, 1, lib.UGate, builtin=True),
133	CustomInstruction("p", 1, 1, lib.PhaseGate, builtin=True),
134	CustomInstruction("x", 0, 1, lib.XGate),
135	CustomInstruction("y", 0, 1, lib.YGate),
136	CustomInstruction("z", 0, 1, lib.ZGate),
137	CustomInstruction("h", 0, 1, lib.HGate),
138	CustomInstruction("s", 0, 1, lib.SGate),
139	CustomInstruction("sdg", 0, 1, lib.SdgGate),
140	CustomInstruction("t", 0, 1, lib.TGate),
141	CustomInstruction("tdg", 0, 1, lib.TdgGate),
142	CustomInstruction("rx", 1, 1, lib.RXGate),
143	CustomInstruction("ry", 1, 1, lib.RYGate),
144	CustomInstruction("rz", 1, 1, lib.RZGate),
145	CustomInstruction("sx", 0, 1, lib.SXGate, builtin=True),
146	CustomInstruction("sxdg", 0, 1, lib.SXdgGate, builtin=True),
147	CustomInstruction("cz", 0, 2, lib.CZGate),
148	CustomInstruction("cy", 0, 2, lib.CYGate),
149	CustomInstruction("swap", 0, 2, lib.SwapGate, builtin=True),
150	CustomInstruction("ch", 0, 2, lib.CHGate),
151	CustomInstruction("ccx", 0, 3, lib.CCXGate),
152	CustomInstruction("cswap", 0, 3, lib.CSwapGate, builtin=True),
153	CustomInstruction("crx", 1, 2, lib.CRXGate, builtin=True),
154	CustomInstruction("cry", 1, 2, lib.CRYGate, builtin=True),
155	CustomInstruction("crz", 1, 2, lib.CRZGate),
156	CustomInstruction("cu1", 1, 2, lib.CU1Gate),
157	CustomInstruction("cp", 1, 2, lib.CPhaseGate, builtin=True),
158	CustomInstruction("cu3", 3, 2, lib.CU3Gate),
159	CustomInstruction("csx", 0, 2, lib.CSXGate, builtin=True),
160	CustomInstruction("cu", 4, 2, lib.CUGate, builtin=True),
161	CustomInstruction("rxx", 1, 2, lib.RXXGate, builtin=True),
162	CustomInstruction("rzz", 1, 2, lib.RZZGate, builtin=True),
163	CustomInstruction("rccx", 0, 3, lib.RCCXGate, builtin=True),
164	CustomInstruction("rc3x", 0, 4, lib.RC3XGate, builtin=True),
165	CustomInstruction("c3x", 0, 4, lib.C3XGate, builtin=True),
166	CustomInstruction("c3sqrtx", 0, 4, lib.C3SXGate, builtin=True),
167	CustomInstruction("c4x", 0, 5, lib.C4XGate, builtin=True),
168	CustomInstruction("delay", 1, 1, _generate_delay),
169	)
170
171	LEGACY_CUSTOM_CLASSICAL = (	1✔
172	CustomClassical("asin", 1, math.asin),
173	CustomClassical("acos", 1, math.acos),
174	CustomClassical("atan", 1, math.atan),
175	)
176
177
178	def from_bytecode(bytecode, custom_instructions: Iterable[CustomInstruction]):	1✔
179	"""Loop through the Rust bytecode iterator `bytecode` producing a
180	:class:`~qiskit.circuit.QuantumCircuit` instance from it. All the hard work is done in Rust
181	space where operations are faster; here, we're just about looping through the instructions as
182	fast as possible, doing as little calculation as we can in Python space. The Python-space
183	components are the vast majority of the runtime.
184
185	The "bytecode", and so also this Python function, is very tightly coupled to the output of the
186	Rust parser. The bytecode itself is largely defined by Rust; from Python space, the iterator is
187	over essentially a 2-tuple of `(opcode, operands)`. The `operands` are fixed by Rust, and
188	assumed to be correct by this function.
189
190	The Rust code is responsible for all validation. If this function causes any errors to be
191	raised by Qiskit (except perhaps for some symbolic manipulations of `Parameter` objects), we
192	should consider that a bug in the Rust code."""
193	# The method `QuantumCircuit._append` is a semi-public method, so isn't really subject to
194	# "protected access".
195	# pylint: disable=protected-access
196	qc = QuantumCircuit()	1✔
197	qubits = []	1✔
198	clbits = []	1✔
199	gates = []	1✔
200	has_u, has_cx = False, False	1✔
201	for custom in custom_instructions:	1✔
202	gates.append(custom.constructor)	1✔
203	if custom.name == "U":	1✔
204	has_u = True	1✔
205	elif custom.name == "CX":	1✔
206	has_cx = True	1✔
207	if not has_u:	1✔
208	gates.append(lib.UGate)	1✔
209	if not has_cx:	1✔
210	gates.append(lib.CXGate)	1✔
211	# Pull this out as an explicit iterator so we can manually advance the loop in `DeclareGate`
212	# contexts easily.
213	bc = iter(bytecode)	1✔
214	for op in bc:	1✔
215	# We have to check `op.opcode` so many times, it's worth pulling out the extra attribute
216	# access. We should check the opcodes in order of their likelihood to be in the OQ2 program
217	# for speed. Gate applications are by far the most common for long programs. This function
218	# is deliberately long and does not use hashmaps or function lookups for speed in
219	# Python-space.
220	opcode = op.opcode	1✔
221	# `OpCode` is an `enum` in Rust, but its instances don't have the same singleton property as
222	# Python `enum.Enum` objects.
223	if opcode == OpCode.Gate:	1✔
224	gate_id, parameters, op_qubits = op.operands	1✔
225	qc._append(	1✔
226	CircuitInstruction(gates[gate_id](*parameters), [qubits[q] for q in op_qubits])
227	)
228	elif opcode == OpCode.ConditionedGate:	1✔
229	gate_id, parameters, op_qubits, creg, value = op.operands	1✔
230	gate = gates[gate_id](*parameters).c_if(qc.cregs[creg], value)	1✔
231	qc._append(CircuitInstruction(gate, [qubits[q] for q in op_qubits]))	1✔
232	elif opcode == OpCode.Measure:	1✔
233	qubit, clbit = op.operands	1✔
234	qc._append(CircuitInstruction(Measure(), (qubits[qubit],), (clbits[clbit],)))	1✔
235	elif opcode == OpCode.ConditionedMeasure:	1✔
236	qubit, clbit, creg, value = op.operands	1✔
237	measure = Measure().c_if(qc.cregs[creg], value)	1✔
238	qc._append(CircuitInstruction(measure, (qubits[qubit],), (clbits[clbit],)))	1✔
239	elif opcode == OpCode.Reset:	1✔
240	qc._append(CircuitInstruction(Reset(), (qubits[op.operands[0]],)))	1✔
241	elif opcode == OpCode.ConditionedReset:	1✔
242	qubit, creg, value = op.operands	1✔
243	reset = Reset().c_if(qc.cregs[creg], value)	1✔
244	qc._append(CircuitInstruction(reset, (qubits[qubit],)))	1✔
245	elif opcode == OpCode.Barrier:	1✔
246	op_qubits = op.operands[0]	1✔
247	qc._append(CircuitInstruction(Barrier(len(op_qubits)), [qubits[q] for q in op_qubits]))	1✔
248	elif opcode == OpCode.DeclareQreg:	1✔
249	name, size = op.operands	1✔
250	register = QuantumRegister(size, name)	1✔
251	qubits += register[:]	1✔
252	qc.add_register(register)	1✔
253	elif opcode == OpCode.DeclareCreg:	1✔
254	name, size = op.operands	1✔
255	register = ClassicalRegister(size, name)	1✔
256	clbits += register[:]	1✔
257	qc.add_register(register)	1✔
258	elif opcode == OpCode.SpecialInclude:	1✔
259	# Including `qelib1.inc` is pretty much universal, and we treat its gates as having
260	# special relationships to the Qiskit ones, so we don't actually parse it; we just
261	# short-circuit to add its pre-calculated content to our state.
262	(indices,) = op.operands	1✔
263	for index in indices:	1✔
264	gates.append(QELIB1[index])	1✔
265	elif opcode == OpCode.DeclareGate:	1✔
266	name, num_qubits = op.operands	1✔
267	# This inner loop advances the iterator of the outer loop as well, since `bc` is a
268	# manually created iterator, rather than an implicit one from the first loop.
269	inner_bc = []	1✔
270	for inner_op in bc:	1✔
271	if inner_op.opcode == OpCode.EndDeclareGate:	1✔
272	break	1✔
273	inner_bc.append(inner_op)	1✔
274	# Technically there's a quadratic dependency in the number of gates here, which could be
275	# fixed by just sharing a reference to `gates` rather than recreating a new object.
276	# Gates can't ever be removed from the list, so it wouldn't get out-of-date, though
277	# there's a minor risk of somewhere accidentally mutating it instead, and in practice
278	# the cost shouldn't really matter.
279	gates.append(_gate_builder(name, num_qubits, tuple(gates), inner_bc))	1✔
280	elif opcode == OpCode.DeclareOpaque:	1✔
281	name, num_qubits = op.operands	1✔
282	gates.append(_opaque_builder(name, num_qubits))	1✔
283	else:
284	raise ValueError(f"invalid operation: {op}")	×
285	return qc	1✔
286
287
288	class _DefinedGate(Gate):	1✔
289	"""A gate object defined by a `gate` statement in an OpenQASM 2 program. This object lazily	1✔
290	binds its parameters to its definition, so it is only synthesised when required."""
291
292	def __init__(self, name, num_qubits, params, gates, bytecode):	1✔
293	self._gates = gates	1✔
294	self._bytecode = bytecode	1✔
295	super().__init__(name, num_qubits, list(params))	1✔
296
297	def _define(self):	1✔
298	# This is a stripped-down version of the bytecode interpreter; there's very few opcodes that
299	# we actually need to handle within gate bodies.
300	# pylint: disable=protected-access
301	qubits = [Qubit() for _ in [None] * self.num_qubits]	1✔
302	qc = QuantumCircuit(qubits)	1✔
303	for op in self._bytecode:	1✔
304	if op.opcode == OpCode.Gate:	1✔
305	gate_id, args, op_qubits = op.operands	1✔
306	qc._append(	1✔
307	CircuitInstruction(
308	self._gates[gate_id](*(_evaluate_argument(a, self.params) for a in args)),
309	[qubits[q] for q in op_qubits],
310	)
311	)
312	elif op.opcode == OpCode.Barrier:	1✔
313	op_qubits = op.operands[0]	1✔
314	qc._append(	1✔
315	CircuitInstruction(Barrier(len(op_qubits)), [qubits[q] for q in op_qubits])
316	)
317	else:
318	raise ValueError(f"received invalid bytecode to build gate: {op}")	×
319	self._definition = qc	1✔
320
321	def __array__(self, dtype=None, copy=None):	1✔
322	if copy is False:	1✔
NEW 323	raise ValueError("unable to avoid copy while creating an array as requested")	×
324	return np.asarray(Operator(self.definition), dtype=dtype)	1✔
325
326	# It's fiddly to implement pickling for PyO3 types (the bytecode stream), so instead if we need
327	# to pickle ourselves, we just eagerly create the definition and pickle that.
328
329	def __getstate__(self):	1✔
330	return (self.name, self.num_qubits, self.params, self.definition, self.condition)	1✔
331
332	def __setstate__(self, state):	1✔
333	name, num_qubits, params, definition, condition = state	1✔
334	super().__init__(name, num_qubits, params)	1✔
335	self._gates = ()	1✔
336	self._bytecode = ()	1✔
337	self._definition = definition	1✔
338	self._condition = condition	1✔
339
340
341	def _gate_builder(name, num_qubits, known_gates, bytecode):	1✔
342	"""Create a gate-builder function of the signature `*params -> Gate` for a gate with a given
343	`name`. This produces a `_DefinedGate` class, whose `_define` method runs through the given
344	`bytecode` using the current list of `known_gates` to interpret the gate indices.
345
346	The indirection here is mostly needed to correctly close over `known_gates` and `bytecode`."""
347
348	def definer(*params):	1✔
349	return _DefinedGate(name, num_qubits, params, known_gates, tuple(bytecode))	1✔
350
351	return definer	1✔
352
353
354	def _opaque_builder(name, num_qubits):	1✔
355	"""Create a gate-builder function of the signature `*params -> Gate` for an opaque gate with a
356	given `name`, which takes the given numbers of qubits."""
357
358	def definer(*params):	1✔
359	return Gate(name, num_qubits, params)	1✔
360
361	return definer	1✔
362
363
364	# The natural way to reduce returns in this function would be to use a lookup table for the opcodes,
365	# but the PyO3 enum entities aren't (currently) hashable.
366	def _evaluate_argument(expr, parameters): # pylint: disable=too-many-return-statements	1✔
367	"""Inner recursive function to calculate the value of a mathematical expression given the
368	concrete values in the `parameters` field."""
369	if isinstance(expr, ExprConstant):	1✔
370	return expr.value	1✔
371	if isinstance(expr, ExprArgument):	1✔
372	return parameters[expr.index]	1✔
373	if isinstance(expr, ExprUnary):	1✔
374	inner = _evaluate_argument(expr.argument, parameters)	1✔
375	opcode = expr.opcode	1✔
376	if opcode == UnaryOpCode.Negate:	1✔
377	return -inner	1✔
378	if opcode == UnaryOpCode.Cos:	1✔
379	return math.cos(inner)	1✔
380	if opcode == UnaryOpCode.Exp:	1✔
381	return math.exp(inner)	1✔
382	if opcode == UnaryOpCode.Ln:	1✔
383	return math.log(inner)	1✔
384	if opcode == UnaryOpCode.Sin:	1✔
385	return math.sin(inner)	1✔
386	if opcode == UnaryOpCode.Sqrt:	1✔
387	return math.sqrt(inner)	1✔
388	if opcode == UnaryOpCode.Tan:	1✔
389	return math.tan(inner)	1✔
390	raise ValueError(f"unhandled unary opcode: {opcode}")	×
391	if isinstance(expr, ExprBinary):	1✔
392	left = _evaluate_argument(expr.left, parameters)	1✔
393	right = _evaluate_argument(expr.right, parameters)	1✔
394	opcode = expr.opcode	1✔
395	if opcode == BinaryOpCode.Add:	1✔
396	return left + right	1✔
397	if opcode == BinaryOpCode.Subtract:	1✔
398	return left - right	1✔
399	if opcode == BinaryOpCode.Multiply:	1✔
400	return left * right	1✔
401	if opcode == BinaryOpCode.Divide:	1✔
402	return left / right	1✔
403	if opcode == BinaryOpCode.Power:	1✔
404	return left**right	1✔
405	raise ValueError(f"unhandled binary opcode: {opcode}")	×
406	if isinstance(expr, ExprCustom):	1✔
407	return expr.callable(*(_evaluate_argument(x, parameters) for x in expr.arguments))	1✔
408	raise ValueError(f"unhandled expression type: {expr}")	×

Qiskit / qiskit / 9405162251

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous