qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/circuit/quantumcircuitdata.py

@@ -0,0 +1,138 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019.
+#
+# 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.
+
+"""A wrapper class for the purposes of validating modifications to
+QuantumCircuit.data while maintaining the interface of a python list."""
+
+from collections.abc import MutableSequence
+
+import qiskit._accelerate.quantum_circuit
+
+from .exceptions import CircuitError
+from .instruction import Instruction
+from .operation import Operation
+
+
+CircuitInstruction = qiskit._accelerate.quantum_circuit.CircuitInstruction
+
+
+class QuantumCircuitData(MutableSequence):
+    """A wrapper class for the purposes of validating modifications to
+    QuantumCircuit.data while maintaining the interface of a python list."""
+
+    def __init__(self, circuit):
+        self._circuit = circuit
+
+    def __getitem__(self, i):
+        return self._circuit._data[i]
+
+    def __setitem__(self, key, value):
+        # For now (Terra 0.21), the `QuantumCircuit.data` setter is meant to perform validation, so
+        # we do the same qubit checks that `QuantumCircuit.append` would do.
+        if isinstance(value, CircuitInstruction):
+            operation, qargs, cargs = value.operation, value.qubits, value.clbits
+        else:
+            # Handle the legacy 3-tuple format.
+            operation, qargs, cargs = value
+        value = self._resolve_legacy_value(operation, qargs, cargs)
+        self._circuit._data[key] = value
+        if isinstance(value.operation, Instruction):
+            self._circuit._update_parameter_table(value)
+
+    def _resolve_legacy_value(self, operation, qargs, cargs) -> CircuitInstruction:
+        """Resolve the old-style 3-tuple into the new :class:`CircuitInstruction` type."""
+        if not isinstance(operation, Operation) and hasattr(operation, "to_instruction"):
+            operation = operation.to_instruction()
+        if not isinstance(operation, Operation):
+            raise CircuitError("object is not an Operation.")
+
+        expanded_qargs = [self._circuit.qbit_argument_conversion(qarg) for qarg in qargs or []]
+        expanded_cargs = [self._circuit.cbit_argument_conversion(carg) for carg in cargs or []]
+
+        if isinstance(operation, Instruction):
+            broadcast_args = list(operation.broadcast_arguments(expanded_qargs, expanded_cargs))
+        else:
+            broadcast_args = list(
+                Instruction.broadcast_arguments(operation, expanded_qargs, expanded_cargs)
+            )
+
+        if len(broadcast_args) > 1:
+            raise CircuitError(
+                "QuantumCircuit.data modification does not support argument broadcasting."
+            )
+
+        qargs, cargs = broadcast_args[0]
+
+        self._circuit._check_dups(qargs)
+        return CircuitInstruction(operation, tuple(qargs), tuple(cargs))
+
+    def insert(self, index, value):
+        self._circuit._data.insert(index, CircuitInstruction(None, (), ()))
+        try:
+            self[index] = value
+        except CircuitError:
+            del self._circuit._data[index]
+            raise
+
+    def __iter__(self):
+        return iter(self._circuit._data)
+
+    def __delitem__(self, i):
+        del self._circuit._data[i]
+
+    def __len__(self):
+        return len(self._circuit._data)
+
+    def __cast(self, other):
+        return list(other._circuit._data) if isinstance(other, QuantumCircuitData) else other
+
+    def __repr__(self):
+        return repr(list(self._circuit._data))
+
+    def __lt__(self, other):
+        return list(self._circuit._data) < self.__cast(other)
+
+    def __le__(self, other):
+        return list(self._circuit._data) <= self.__cast(other)
+
+    def __eq__(self, other):
+        return self._circuit._data == self.__cast(other)
+
+    def __gt__(self, other):
+        return list(self._circuit._data) > self.__cast(other)
+
+    def __ge__(self, other):
+        return list(self._circuit._data) >= self.__cast(other)
+
+    def __add__(self, other):
+        return list(self._circuit._data) + self.__cast(other)
+
+    def __radd__(self, other):
+        return self.__cast(other) + list(self._circuit._data)
+
+    def __mul__(self, n):
+        return list(self._circuit._data) * n
+
+    def __rmul__(self, n):
+        return n * list(self._circuit._data)
+
+    def sort(self, *args, **kwargs):
+        """In-place stable sort. Accepts arguments of list.sort."""
+        data = list(self._circuit._data)
+        data.sort(*args, **kwargs)
+        self._circuit._data.clear()
+        self._circuit._data.reserve(len(data))
+        self._circuit._data.extend(data)
+
+    def copy(self):
+        """Returns a shallow copy of instruction list."""
+        return list(self._circuit._data)

qiskit/circuit/quantumregister.py

@@ -0,0 +1,90 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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.
+
+# pylint: disable=bad-docstring-quotes
+
+"""
+Quantum register reference object.
+"""
+import itertools
+
+from qiskit.circuit.exceptions import CircuitError
+
+# Over-specific import to avoid cyclic imports.
+from qiskit.utils.deprecation import deprecate_func
+from .register import Register
+from .bit import Bit
+
+
+class Qubit(Bit):
+    """Implement a quantum bit."""
+
+    __slots__ = ()
+
+    def __init__(self, register=None, index=None):
+        """Creates a qubit.
+
+        Args:
+            register (QuantumRegister): Optional. A quantum register containing the bit.
+            index (int): Optional. The index of the bit in its containing register.
+
+        Raises:
+            CircuitError: if the provided register is not a valid :class:`QuantumRegister`
+        """
+
+        if register is None or isinstance(register, QuantumRegister):
+            super().__init__(register, index)
+        else:
+            raise CircuitError(
+                "Qubit needs a QuantumRegister and %s was provided" % type(register).__name__
+            )
+
+
+class QuantumRegister(Register):
+    """Implement a quantum register."""
+
+    # Counter for the number of instances in this class.
+    instances_counter = itertools.count()
+    # Prefix to use for auto naming.
+    prefix = "q"
+    bit_type = Qubit
+
+    @deprecate_func(
+        additional_msg=(
+            "Correct exporting to OpenQASM 2 is the responsibility of a larger exporter; it cannot "
+            "safely be done on an object-by-object basis without context. No replacement will be "
+            "provided, because the premise is wrong."
+        ),
+        since="0.23.0",
+        package_name="qiskit-terra",
+    )
+    def qasm(self):
+        """Return OPENQASM string for this register."""
+        return "qreg %s[%d];" % (self.name, self.size)
+
+
+class AncillaQubit(Qubit):
+    """A qubit used as ancillary qubit."""
+
+    __slots__ = ()
+
+    pass
+
+
+class AncillaRegister(QuantumRegister):
+    """Implement an ancilla register."""
+
+    # Counter for the number of instances in this class.
+    instances_counter = itertools.count()
+    # Prefix to use for auto naming.
+    prefix = "a"
+    bit_type = AncillaQubit

qiskit/circuit/random/__init__.py

@@ -0,0 +1,15 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# 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.
+
+"""Method for generating random circuits."""
+
+from .utils import random_circuit

qiskit/circuit/random/utils.py

@@ -0,0 +1,209 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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.
+
+"""Utility functions for generating random circuits."""
+
+import numpy as np
+
+from qiskit.circuit import ClassicalRegister, QuantumCircuit, CircuitInstruction
+from qiskit.circuit import Reset
+from qiskit.circuit.library import standard_gates
+from qiskit.circuit.exceptions import CircuitError
+
+
+def random_circuit(
+    num_qubits, depth, max_operands=4, measure=False, conditional=False, reset=False, seed=None
+):
+    """Generate random circuit of arbitrary size and form.
+
+    This function will generate a random circuit by randomly selecting gates
+    from the set of standard gates in :mod:`qiskit.extensions`. For example:
+
+    .. plot::
+       :include-source:
+
+       from qiskit.circuit.random import random_circuit
+
+       circ = random_circuit(2, 2, measure=True)
+       circ.draw(output='mpl')
+
+    Args:
+        num_qubits (int): number of quantum wires
+        depth (int): layers of operations (i.e. critical path length)
+        max_operands (int): maximum qubit operands of each gate (between 1 and 4)
+        measure (bool): if True, measure all qubits at the end
+        conditional (bool): if True, insert middle measurements and conditionals
+        reset (bool): if True, insert middle resets
+        seed (int): sets random seed (optional)
+
+    Returns:
+        QuantumCircuit: constructed circuit
+
+    Raises:
+        CircuitError: when invalid options given
+    """
+    if num_qubits == 0:
+        return QuantumCircuit()
+    if max_operands < 1 or max_operands > 4:
+        raise CircuitError("max_operands must be between 1 and 4")
+    max_operands = max_operands if num_qubits > max_operands else num_qubits
+
+    gates_1q = [
+        # (Gate class, number of qubits, number of parameters)
+        (standard_gates.IGate, 1, 0),
+        (standard_gates.SXGate, 1, 0),
+        (standard_gates.XGate, 1, 0),
+        (standard_gates.RZGate, 1, 1),
+        (standard_gates.RGate, 1, 2),
+        (standard_gates.HGate, 1, 0),
+        (standard_gates.PhaseGate, 1, 1),
+        (standard_gates.RXGate, 1, 1),
+        (standard_gates.RYGate, 1, 1),
+        (standard_gates.SGate, 1, 0),
+        (standard_gates.SdgGate, 1, 0),
+        (standard_gates.SXdgGate, 1, 0),
+        (standard_gates.TGate, 1, 0),
+        (standard_gates.TdgGate, 1, 0),
+        (standard_gates.UGate, 1, 3),
+        (standard_gates.U1Gate, 1, 1),
+        (standard_gates.U2Gate, 1, 2),
+        (standard_gates.U3Gate, 1, 3),
+        (standard_gates.YGate, 1, 0),
+        (standard_gates.ZGate, 1, 0),
+    ]
+    if reset:
+        gates_1q.append((Reset, 1, 0))
+    gates_2q = [
+        (standard_gates.CXGate, 2, 0),
+        (standard_gates.DCXGate, 2, 0),
+        (standard_gates.CHGate, 2, 0),
+        (standard_gates.CPhaseGate, 2, 1),
+        (standard_gates.CRXGate, 2, 1),
+        (standard_gates.CRYGate, 2, 1),
+        (standard_gates.CRZGate, 2, 1),
+        (standard_gates.CSXGate, 2, 0),
+        (standard_gates.CUGate, 2, 4),
+        (standard_gates.CU1Gate, 2, 1),
+        (standard_gates.CU3Gate, 2, 3),
+        (standard_gates.CYGate, 2, 0),
+        (standard_gates.CZGate, 2, 0),
+        (standard_gates.RXXGate, 2, 1),
+        (standard_gates.RYYGate, 2, 1),
+        (standard_gates.RZZGate, 2, 1),
+        (standard_gates.RZXGate, 2, 1),
+        (standard_gates.XXMinusYYGate, 2, 2),
+        (standard_gates.XXPlusYYGate, 2, 2),
+        (standard_gates.ECRGate, 2, 0),
+        (standard_gates.CSGate, 2, 0),
+        (standard_gates.CSdgGate, 2, 0),
+        (standard_gates.SwapGate, 2, 0),
+        (standard_gates.iSwapGate, 2, 0),
+    ]
+    gates_3q = [
+        (standard_gates.CCXGate, 3, 0),
+        (standard_gates.CSwapGate, 3, 0),
+        (standard_gates.CCZGate, 3, 0),
+        (standard_gates.RCCXGate, 3, 0),
+    ]
+    gates_4q = [
+        (standard_gates.C3SXGate, 4, 0),
+        (standard_gates.RC3XGate, 4, 0),
+    ]
+
+    gates = gates_1q.copy()
+    if max_operands >= 2:
+        gates.extend(gates_2q)
+    if max_operands >= 3:
+        gates.extend(gates_3q)
+    if max_operands >= 4:
+        gates.extend(gates_4q)
+    gates = np.array(
+        gates, dtype=[("class", object), ("num_qubits", np.int64), ("num_params", np.int64)]
+    )
+    gates_1q = np.array(gates_1q, dtype=gates.dtype)
+
+    qc = QuantumCircuit(num_qubits)
+
+    if measure or conditional:
+        cr = ClassicalRegister(num_qubits, "c")
+        qc.add_register(cr)
+
+    if seed is None:
+        seed = np.random.randint(0, np.iinfo(np.int32).max)
+    rng = np.random.default_rng(seed)
+
+    qubits = np.array(qc.qubits, dtype=object, copy=True)
+
+    # Apply arbitrary random operations in layers across all qubits.
+    for layer_number in range(depth):
+        # We generate all the randomness for the layer in one go, to avoid many separate calls to
+        # the randomisation routines, which can be fairly slow.
+
+        # This reliably draws too much randomness, but it's less expensive than looping over more
+        # calls to the rng. After, trim it down by finding the point when we've used all the qubits.
+        gate_specs = rng.choice(gates, size=len(qubits))
+        cumulative_qubits = np.cumsum(gate_specs["num_qubits"], dtype=np.int64)
+        # Efficiently find the point in the list where the total gates would use as many as
+        # possible of, but not more than, the number of qubits in the layer.  If there's slack, fill
+        # it with 1q gates.
+        max_index = np.searchsorted(cumulative_qubits, num_qubits, side="right")
+        gate_specs = gate_specs[:max_index]
+        slack = num_qubits - cumulative_qubits[max_index - 1]
+        if slack:
+            gate_specs = np.hstack((gate_specs, rng.choice(gates_1q, size=slack)))
+
+        # For efficiency in the Python loop, this uses Numpy vectorisation to pre-calculate the
+        # indices into the lists of qubits and parameters for every gate, and then suitably
+        # randomises those lists.
+        q_indices = np.empty(len(gate_specs) + 1, dtype=np.int64)
+        p_indices = np.empty(len(gate_specs) + 1, dtype=np.int64)
+        q_indices[0] = p_indices[0] = 0
+        np.cumsum(gate_specs["num_qubits"], out=q_indices[1:])
+        np.cumsum(gate_specs["num_params"], out=p_indices[1:])
+        parameters = rng.uniform(0, 2 * np.pi, size=p_indices[-1])
+        rng.shuffle(qubits)
+
+        # We've now generated everything we're going to need.  Now just to add everything.  The
+        # conditional check is outside the two loops to make the more common case of no conditionals
+        # faster, since in Python we don't have a compiler to do this for us.
+        if conditional and layer_number != 0:
+            is_conditional = rng.random(size=len(gate_specs)) < 0.1
+            condition_values = rng.integers(
+                0, 1 << min(num_qubits, 63), size=np.count_nonzero(is_conditional)
+            )
+            c_ptr = 0
+            for gate, q_start, q_end, p_start, p_end, is_cond in zip(
+                gate_specs["class"],
+                q_indices[:-1],
+                q_indices[1:],
+                p_indices[:-1],
+                p_indices[1:],
+                is_conditional,
+            ):
+                operation = gate(*parameters[p_start:p_end])
+                if is_cond:
+                    qc.measure(qc.qubits, cr)
+                    # The condition values are required to be bigints, not Numpy's fixed-width type.
+                    operation = operation.c_if(cr, int(condition_values[c_ptr]))
+                    c_ptr += 1
+                qc._append(CircuitInstruction(operation=operation, qubits=qubits[q_start:q_end]))
+        else:
+            for gate, q_start, q_end, p_start, p_end in zip(
+                gate_specs["class"], q_indices[:-1], q_indices[1:], p_indices[:-1], p_indices[1:]
+            ):
+                operation = gate(*parameters[p_start:p_end])
+                qc._append(CircuitInstruction(operation=operation, qubits=qubits[q_start:q_end]))
+
+    if measure:
+        qc.measure(qc.qubits, cr)
+
+    return qc