qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/circuit/store.py

@@ -0,0 +1,89 @@
+# 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.
+
+"""The 'Store' operation."""
+
+from __future__ import annotations
+
+import typing
+
+from .exceptions import CircuitError
+from .classical import expr, types
+from .instruction import Instruction
+
+
+def _handle_equal_types(lvalue: expr.Expr, rvalue: expr.Expr, /) -> tuple[expr.Expr, expr.Expr]:
+    return lvalue, rvalue
+
+
+def _handle_implicit_cast(lvalue: expr.Expr, rvalue: expr.Expr, /) -> tuple[expr.Expr, expr.Expr]:
+    return lvalue, expr.Cast(rvalue, lvalue.type, implicit=True)
+
+
+def _requires_lossless_cast(lvalue: expr.Expr, rvalue: expr.Expr, /) -> typing.NoReturn:
+    raise CircuitError(f"an explicit cast is required from '{rvalue.type}' to '{lvalue.type}'")
+
+
+def _requires_dangerous_cast(lvalue: expr.Expr, rvalue: expr.Expr, /) -> typing.NoReturn:
+    raise CircuitError(
+        f"an explicit cast is required from '{rvalue.type}' to '{lvalue.type}', which may be lossy"
+    )
+
+
+def _no_cast_possible(lvalue: expr.Expr, rvalue: expr.Expr) -> typing.NoReturn:
+    raise CircuitError(f"no cast is possible from '{rvalue.type}' to '{lvalue.type}'")
+
+
+_HANDLE_CAST = {
+    types.CastKind.EQUAL: _handle_equal_types,
+    types.CastKind.IMPLICIT: _handle_implicit_cast,
+    types.CastKind.LOSSLESS: _requires_lossless_cast,
+    types.CastKind.DANGEROUS: _requires_dangerous_cast,
+    types.CastKind.NONE: _no_cast_possible,
+}
+
+
+class Store(Instruction):
+    """A manual storage of some classical value to a classical memory location.
+
+    This is a low-level primitive of the classical-expression handling (similar to how
+    :class:`~.circuit.Measure` is a primitive for quantum measurement), and is not safe for
+    subclassing."""
+
+    # This is a compiler/backend intrinsic operation, separate to any quantum processing.
+    _directive = True
+
+    def __init__(self, lvalue: expr.Expr, rvalue: expr.Expr):
+        """
+        Args:
+            lvalue: the memory location being stored into.
+            rvalue: the expression result being stored.
+        """
+        if not expr.is_lvalue(lvalue):
+            raise CircuitError(f"'{lvalue}' is not an l-value")
+
+        cast_kind = types.cast_kind(rvalue.type, lvalue.type)
+        if (handler := _HANDLE_CAST.get(cast_kind)) is None:
+            raise RuntimeError(f"unhandled cast kind required: {cast_kind}")
+        lvalue, rvalue = handler(lvalue, rvalue)
+
+        super().__init__("store", 0, 0, [lvalue, rvalue])
+
+    @property
+    def lvalue(self):
+        """Get the l-value :class:`~.expr.Expr` node that is being stored to."""
+        return self.params[0]
+
+    @property
+    def rvalue(self):
+        """Get the r-value :class:`~.expr.Expr` node that is being written into the l-value."""
+        return self.params[1]

qiskit/circuit/tools/__init__.py

@@ -0,0 +1,16 @@
+# 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.
+
+"""
+Helpful routines
+"""
+from .pi_check import pi_check

qiskit/circuit/tools/pi_check.py

@@ -0,0 +1,185 @@
+# 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.
+# pylint: disable=too-many-return-statements
+
+"""Check if number close to values of PI
+"""
+
+import numpy as np
+from qiskit.circuit.parameterexpression import ParameterExpression
+from qiskit.exceptions import QiskitError
+
+MAX_FRAC = 16
+N, D = np.meshgrid(np.arange(1, MAX_FRAC + 1), np.arange(1, MAX_FRAC + 1))
+FRAC_MESH = N / D * np.pi
+RECIP_MESH = N / D / np.pi
+POW_LIST = np.pi ** np.arange(2, 5)
+
+
+def pi_check(inpt, eps=1e-9, output="text", ndigits=None):
+    """Computes if a number is close to an integer
+    fraction or multiple of PI and returns the
+    corresponding string.
+
+    Args:
+        inpt (float): Number to check.
+        eps (float): EPS to check against.
+        output (str): Options are 'text' (default),
+                      'latex', 'mpl', and 'qasm'.
+        ndigits (int or None): Number of digits to print
+                               if returning raw inpt.
+                               If `None` (default), Python's
+                               default float formatting is used.
+
+    Returns:
+        str: string representation of output.
+
+    Raises:
+        QiskitError: if output is not a valid option.
+    """
+    if isinstance(inpt, ParameterExpression):
+        param_str = str(inpt)
+        values = inpt._symbol_expr.values()
+        for val in values:
+            pi = pi_check(abs(float(val)), eps=eps, output=output, ndigits=ndigits)
+            try:
+                _ = float(pi)
+            except (ValueError, TypeError):
+                import qiskit._accelerate.circuit
+
+                sym_str = str(qiskit._accelerate.circuit.ParameterExpression.Value(abs(val)))
+                param_str = param_str.replace(sym_str, pi)
+        return param_str
+    elif isinstance(inpt, str):
+        return inpt
+
+    def normalize(single_inpt):
+        if abs(single_inpt) < eps:
+            return "0"
+
+        if output == "text":
+            pi = "π"
+        elif output == "qasm":
+            pi = "pi"
+        elif output == "latex":
+            pi = "\\pi"
+        elif output == "mpl":
+            pi = "$\\pi$"
+        else:
+            raise QiskitError("pi_check parameter output should be text, latex, mpl, or qasm.")
+
+        neg_str = "-" if single_inpt < 0 else ""
+
+        # First check is for whole multiples of pi
+        val = single_inpt / np.pi
+        if abs(val) >= 1 - eps:
+            if abs(abs(val) - abs(round(val))) < eps:
+                val = int(abs(round(val)))
+                if abs(val) == 1:
+                    str_out = f"{neg_str}{pi}"
+                else:
+                    if output == "qasm":
+                        str_out = f"{neg_str}{val}*{pi}"
+                    else:
+                        str_out = f"{neg_str}{val}{pi}"
+                return str_out
+
+        # Second is a check for powers of pi
+        if abs(single_inpt) > np.pi:
+            power = np.where(abs(abs(single_inpt) - POW_LIST) < eps)
+            if power[0].shape[0]:
+                if output == "qasm":
+                    if ndigits is None:
+                        str_out = str(single_inpt)
+                    else:
+                        str_out = f"{single_inpt:.{ndigits}g}"
+                elif output == "latex":
+                    str_out = f"{neg_str}{pi}^{power[0][0] + 2}"
+                elif output == "mpl":
+                    str_out = f"{neg_str}{pi}$^{power[0][0] + 2}$"
+                else:
+                    str_out = f"{neg_str}{pi}**{power[0][0] + 2}"
+                return str_out
+
+        # Third is a check for a number larger than MAX_FRAC * pi, not a
+        # multiple or power of pi, since no fractions will exceed MAX_FRAC * pi
+        if abs(single_inpt) >= (MAX_FRAC * np.pi):
+            if ndigits is None:
+                str_out = str(single_inpt)
+            else:
+                str_out = f"{single_inpt:.{ndigits}g}"
+            return str_out
+
+        # Fourth check is for fractions for 1*pi in the numer and any
+        # number in the denom.
+        val = np.pi / single_inpt
+        if abs(abs(val) - abs(round(val))) < eps:
+            val = int(abs(round(val)))
+            if output == "latex":
+                str_out = f"\\frac{{{neg_str}{pi}}}{{{val}}}"
+            else:
+                str_out = f"{neg_str}{pi}/{val}"
+            return str_out
+
+        # Fifth check is for fractions where the numer > 1*pi and numer
+        # is up to MAX_FRAC*pi and denom is up to MAX_FRAC and all
+        # fractions are reduced. Ex. 15pi/16, 2pi/5, 15pi/2, 16pi/9.
+        frac = np.where(np.abs(abs(single_inpt) - FRAC_MESH) < eps)
+        if frac[0].shape[0]:
+            numer = int(frac[1][0]) + 1
+            denom = int(frac[0][0]) + 1
+            if output == "latex":
+                str_out = f"\\frac{{{neg_str}{numer}{pi}}}{{{denom}}}"
+            elif output == "qasm":
+                str_out = f"{neg_str}{numer}*{pi}/{denom}"
+            else:
+                str_out = f"{neg_str}{numer}{pi}/{denom}"
+            return str_out
+
+        # Sixth check is for fractions where the numer > 1 and numer
+        # is up to MAX_FRAC and denom is up to MAX_FRAC*pi and all
+        # fractions are reduced. Ex. 15/16pi, 2/5pi, 15/2pi, 16/9pi
+        frac = np.where(np.abs(abs(single_inpt) - RECIP_MESH) < eps)
+        if frac[0].shape[0]:
+            numer = int(frac[1][0]) + 1
+            denom = int(frac[0][0]) + 1
+            if denom == 1 and output != "qasm":
+                denom = ""
+            if output == "latex":
+                str_out = f"\\frac{{{neg_str}{numer}}}{{{denom}{pi}}}"
+            elif output == "qasm":
+                str_out = f"{neg_str}{numer}/({denom}*{pi})"
+            else:
+                str_out = f"{neg_str}{numer}/{denom}{pi}"
+            return str_out
+
+        # Nothing found.  The '#' forces a decimal point to be included, which OQ2 needs, but other
+        # formats don't really.
+        if output == "qasm":
+            return f"{single_inpt:#}" if ndigits is None else f"{single_inpt:#.{ndigits}g}"
+        return f"{single_inpt}" if ndigits is None else f"{single_inpt:.{ndigits}g}"
+
+    complex_inpt = complex(inpt)
+    real, imag = map(normalize, [complex_inpt.real, complex_inpt.imag])
+
+    jstr = "\\jmath" if output == "latex" else "j"
+    if real == "0" and imag != "0":
+        str_out = imag + jstr
+    elif real != "0" and imag != "0":
+        op_str = "+"
+        # Remove + if imag negative except for latex fractions
+        if complex_inpt.imag < 0 and (output != "latex" or "\\frac" not in imag):
+            op_str = ""
+        str_out = f"{real}{op_str}{imag}{jstr}"
+    else:
+        str_out = real
+    return str_out

qiskit/circuit/twirling.py

@@ -0,0 +1,145 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2024
+#
+# 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.
+
+"""The twirling module."""
+
+from __future__ import annotations
+import typing
+
+from qiskit._accelerate.twirling import twirl_circuit as twirl_rs
+from qiskit.circuit.quantumcircuit import QuantumCircuit, _copy_metadata
+from qiskit.circuit.gate import Gate
+from qiskit.circuit.library.standard_gates import CXGate, ECRGate, CZGate, iSwapGate
+from qiskit.exceptions import QiskitError
+
+if typing.TYPE_CHECKING:
+    from qiskit.transpiler.target import Target
+
+
+NAME_TO_CLASS = {
+    "cx": CXGate._standard_gate,
+    "ecr": ECRGate._standard_gate,
+    "cz": CZGate._standard_gate,
+    "iswap": iSwapGate._standard_gate,
+}
+
+
+def pauli_twirl_2q_gates(
+    circuit: QuantumCircuit,
+    twirling_gate: None | str | Gate | list[str] | list[Gate] = None,
+    seed: int | None = None,
+    num_twirls: int | None = None,
+    target: Target | None = None,
+) -> QuantumCircuit | list[QuantumCircuit]:
+    """Create copies of a given circuit with Pauli twirling applied around specified two qubit
+    gates.
+
+    If you're running this function with the intent to twirl a circuit to run on hardware this
+    may not be the most efficient way to perform twirling. Especially if the hardware vendor
+    has implemented the :mod:`.primitives` execution interface with :class:`.SamplerV2` and
+    :class:`.EstimatorV2` this most likely is not the best way to apply twirling to your
+    circuit and you'll want to refer to the implementation of :class:`.SamplerV2` and/or
+    :class:`.EstimatorV2` for the specified hardware vendor.
+
+    If the intent of this function is to be run after :func:`.transpile` or
+    :meth:`.PassManager.run` the optional ``target`` argument can be used
+    so that the inserted 1 qubit Pauli gates are synthesized to be
+    compatible with the given :class:`.Target` so the output circuit(s) are
+    still compatible.
+
+    Args:
+        circuit: The circuit to twirl
+        twirling_gate: The gate to twirl, defaults to `None` which means twirl all default gates:
+            :class:`.CXGate`, :class:`.CZGate`, :class:`.ECRGate`, and :class:`.iSwapGate`.
+            If supplied it can either be a single gate or a list of gates either as either a gate
+            object or its string name. Currently only the names `"cx"`, `"cz"`, `"ecr"`,  and
+            `"iswap"` are supported. If a gate object is provided outside the default gates it must
+            have a matrix defined from its :class:`~.Gate.to_matrix` method for the gate to potentially
+            be twirled. If a valid twirling configuration can't be computed that particular gate will
+            be silently ignored and not twirled.
+        seed: An integer seed for the random number generator used internally by this function.
+            If specified this must be between 0 and 18,446,744,073,709,551,615.
+        num_twirls: The number of twirling circuits to build. This defaults to ``None`` and will return
+            a single circuit. If it is an integer a list of circuits with `num_twirls` circuits
+            will be returned.
+        target: If specified an :class:`.Target` instance to use for running single qubit decomposition
+            as part of the Pauli twirling to optimize and map the pauli gates added to the circuit
+            to the specified target.
+
+    Returns:
+        A copy of the given circuit with Pauli twirling applied to each
+        instance of the specified twirling gate.
+    """
+    custom_gates = None
+    if isinstance(twirling_gate, str):
+        gate = NAME_TO_CLASS.get(twirling_gate, None)
+        if gate is None:
+            raise QiskitError(f"The specified gate name {twirling_gate} is not supported")
+        twirling_std_gate = [gate]
+    elif isinstance(twirling_gate, list):
+        custom_gates = []
+        twirling_std_gate = []
+        for gate in twirling_gate:
+            if isinstance(gate, str):
+                gate = NAME_TO_CLASS.get(gate, None)
+                if gate is None:
+                    raise QiskitError(f"The specified gate name {twirling_gate} is not supported")
+                twirling_std_gate.append(gate)
+            else:
+                twirling_gate = getattr(gate, "_standard_gate", None)
+
+                if twirling_gate is None:
+                    custom_gates.append(gate)
+                else:
+                    if twirling_gate in NAME_TO_CLASS.values():
+                        twirling_std_gate.append(twirling_gate)
+                    else:
+                        custom_gates.append(gate)
+        if not custom_gates:
+            custom_gates = None
+        if not twirling_std_gate:
+            twirling_std_gate = None
+    elif twirling_gate is not None:
+        std_gate = getattr(twirling_gate, "_standard_gate", None)
+        if std_gate is None:
+            twirling_std_gate = None
+            custom_gates = [twirling_gate]
+        else:
+            if std_gate in NAME_TO_CLASS.values():
+                twirling_std_gate = [std_gate]
+            else:
+                twirling_std_gate = None
+                custom_gates = [twirling_gate]
+    else:
+        twirling_std_gate = twirling_gate
+    out_twirls = num_twirls
+    if out_twirls is None:
+        out_twirls = 1
+    new_data = twirl_rs(
+        circuit._data,
+        twirling_std_gate,
+        custom_gates,
+        seed,
+        out_twirls,
+        target,
+    )
+    if num_twirls is not None:
+        out_list = []
+        for circ in new_data:
+            new_circ = QuantumCircuit._from_circuit_data(circ)
+            _copy_metadata(circuit, new_circ, "alike")
+            out_list.append(new_circ)
+        return out_list
+    else:
+        out_circ = QuantumCircuit._from_circuit_data(new_data[0])
+        _copy_metadata(circuit, out_circ, "alike")
+        return out_circ

qiskit/compiler/__init__.py

@@ -0,0 +1,27 @@
+# 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.
+
+"""
+=============================================
+Compilation Routines (:mod:`qiskit.compiler`)
+=============================================
+
+.. currentmodule:: qiskit.compiler
+
+Circuit Compilation Functions
+=======================================
+
+.. autofunction:: transpile
+
+"""
+
+from .transpiler import transpile