qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/quantum_info/synthesis/xx_decompose/utilities.py

@@ -0,0 +1,40 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021
+#
+# 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.
+
+"""
+Depository for generic utility snippets.
+"""
+
+from __future__ import annotations
+import warnings
+
+import numpy as np
+
+
+EPSILON = 1e-6  # Fraction(1, 1_000_000)
+
+
+# TODO: THIS IS A STOPGAP!!!
+def safe_arccos(numerator, denominator):
+    """
+    Computes arccos(n/d) with different (better?) numerical stability.
+    """
+    threshold = 0.005
+
+    if abs(numerator) > abs(denominator) and abs(numerator - denominator) < threshold:
+        return 0.0
+    elif abs(numerator) > abs(denominator) and abs(numerator + denominator) < threshold:
+        return np.pi
+    else:
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=RuntimeWarning)
+            return np.arccos(numerator / denominator)

qiskit/quantum_info/synthesis/xx_decompose/weyl.py

@@ -0,0 +1,133 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021
+#
+# 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.
+
+"""
+Simple circuit constructors for Weyl reflections.
+"""
+
+from __future__ import annotations
+import numpy as np
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.library.standard_gates import RXGate, RYGate, RZGate
+
+
+reflection_options = {
+    "no reflection": ([1, 1, 1], 1, []),
+    "reflect XX, YY": ([-1, -1, 1], 1, [RZGate]),
+    "reflect XX, ZZ": ([-1, 1, -1], 1, [RYGate]),
+    "reflect YY, ZZ": ([1, -1, -1], 1, [RXGate]),
+}
+"""
+A table of available reflection transformations on canonical coordinates.
+Entries take the form
+
+    readable_name: (reflection scalars, global phase, [gate constructors]),
+
+where reflection scalars (a, b, c) model the map (x, y, z) |-> (ax, by, cz),
+global phase is a complex unit, and gate constructors are applied in sequence
+and by conjugation to the first qubit and are passed pi as a parameter.
+"""
+
+shift_options = {
+    "no shift": ([0, 0, 0], 1, []),
+    "Z shift": ([0, 0, 1], 1j, [RZGate]),
+    "Y shift": ([0, 1, 0], -1j, [RYGate]),
+    "Y,Z shift": ([0, 1, 1], 1, [RYGate, RZGate]),
+    "X shift": ([1, 0, 0], -1j, [RXGate]),
+    "X,Z shift": ([1, 0, 1], 1, [RXGate, RZGate]),
+    "X,Y shift": ([1, 1, 0], -1, [RXGate, RYGate]),
+    "X,Y,Z shift": ([1, 1, 1], -1j, [RXGate, RYGate, RZGate]),
+}
+"""
+A table of available shift transformations on canonical coordinates.  Entries
+take the form
+
+    readable name: (shift scalars, global phase, [gate constructors]),
+
+where shift scalars model the map
+
+    (x, y, z) |-> (x + a pi / 2, y + b pi / 2, z + c pi / 2) ,
+
+global phase is a complex unit, and gate constructors are applied to the first
+and second qubits and are passed pi as a parameter.
+"""
+
+
+def apply_reflection(reflection_name, coordinate):
+    """
+    Given a reflection type and a canonical coordinate, applies the reflection
+    and describes a circuit which enacts the reflection + a global phase shift.
+    """
+    reflection_scalars, reflection_phase_shift, source_reflection_gates = reflection_options[
+        reflection_name
+    ]
+    reflected_coord = [x * y for x, y in zip(reflection_scalars, coordinate)]
+    source_reflection = QuantumCircuit(2)
+    for gate in source_reflection_gates:
+        source_reflection.append(gate(np.pi), [0])
+
+    return reflected_coord, source_reflection, reflection_phase_shift
+
+
+def apply_shift(shift_name, coordinate):
+    """
+    Given a shift type and a canonical coordinate, applies the shift and
+    describes a circuit which enacts the shift + a global phase shift.
+    """
+    shift_scalars, shift_phase_shift, source_shift_gates = shift_options[shift_name]
+    shifted_coord = [np.pi / 2 * x + y for x, y in zip(shift_scalars, coordinate)]
+
+    source_shift = QuantumCircuit(2)
+    for gate in source_shift_gates:
+        source_shift.append(gate(np.pi), [0])
+        source_shift.append(gate(np.pi), [1])
+
+    return shifted_coord, source_shift, shift_phase_shift
+
+
+def canonical_rotation_circuit(first_index, second_index):
+    """
+    Given a pair of distinct indices 0 ≤ (first_index, second_index) ≤ 2,
+    produces a two-qubit circuit which rotates a canonical gate
+
+        a0 XX + a1 YY + a2 ZZ
+
+    into
+
+        a[first] XX + a[second] YY + a[other] ZZ .
+    """
+    conj = QuantumCircuit(2)
+
+    if (0, 1) == (first_index, second_index):
+        pass  # no need to do anything
+    elif (0, 2) == (first_index, second_index):
+        conj.rx(-np.pi / 2, [0])
+        conj.rx(np.pi / 2, [1])
+    elif (1, 0) == (first_index, second_index):
+        conj.rz(-np.pi / 2, [0])
+        conj.rz(-np.pi / 2, [1])
+    elif (1, 2) == (first_index, second_index):
+        conj.rz(np.pi / 2, [0])
+        conj.rz(np.pi / 2, [1])
+        conj.ry(np.pi / 2, [0])
+        conj.ry(-np.pi / 2, [1])
+    elif (2, 0) == (first_index, second_index):
+        conj.rz(np.pi / 2, [0])
+        conj.rz(np.pi / 2, [1])
+        conj.rx(np.pi / 2, [0])
+        conj.rx(-np.pi / 2, [1])
+    elif (2, 1) == (first_index, second_index):
+        conj.ry(np.pi / 2, [0])
+        conj.ry(-np.pi / 2, [1])
+
+    return conj

qiskit/result/__init__.py

@@ -0,0 +1,67 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# 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.
+
+"""
+=========================================
+Experiment Results (:mod:`qiskit.result`)
+=========================================
+
+.. currentmodule:: qiskit.result
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   Result
+   ResultError
+   Counts
+
+.. autofunction:: marginal_counts
+.. autofunction:: marginal_distribution
+.. autofunction:: marginal_memory
+
+Distributions
+=============
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   ProbDistribution
+   QuasiDistribution
+
+Expectation values
+==================
+
+.. autofunction:: sampled_expectation_value
+
+Mitigation
+==========
+.. autosummary::
+   :toctree: ../stubs/
+
+   BaseReadoutMitigator
+   CorrelatedReadoutMitigator
+   LocalReadoutMitigator
+
+"""
+
+from .result import Result
+from .exceptions import ResultError
+from .utils import marginal_counts
+from .utils import marginal_distribution
+from .utils import marginal_memory
+from .counts import Counts
+
+from .distributions import QuasiDistribution, ProbDistribution
+from .sampled_expval import sampled_expectation_value
+from .mitigation.base_readout_mitigator import BaseReadoutMitigator
+from .mitigation.correlated_readout_mitigator import CorrelatedReadoutMitigator
+from .mitigation.local_readout_mitigator import LocalReadoutMitigator

qiskit/result/counts.py

@@ -0,0 +1,189 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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 container class for counts from a circuit execution."""
+
+import re
+
+from qiskit.result import postprocess
+from qiskit import exceptions
+
+
+# NOTE: A dict subclass should not overload any dunder methods like __getitem__
+# this can cause unexpected behavior and issues as the cPython dict
+# implementation has many standard methods in C for performance and the dunder
+# methods are not always used as expected. For example, update() doesn't call
+# __setitem__ so overloading __setitem__ would not always provide the expected
+# result
+class Counts(dict):
+    """A class to store a counts result from a circuit execution."""
+
+    bitstring_regex = re.compile(r"^[01\s]+$")
+
+    def __init__(self, data, time_taken=None, creg_sizes=None, memory_slots=None):
+        """Build a counts object
+
+        Args:
+            data (dict): The dictionary input for the counts. Where the keys
+                represent a measured classical value and the value is an
+                integer the number of shots with that result.
+                The keys can be one of several formats:
+
+                     * A hexadecimal string of the form ``'0x4a'``
+                     * A bit string prefixed with ``0b`` for example ``'0b1011'``
+                     * A bit string formatted across register and memory slots.
+                       For example, ``'00 10'``.
+                     * A dit string, for example ``'02'``. Note for objects created
+                       with dit strings the ``creg_sizes`` and ``memory_slots``
+                       kwargs don't work and :meth:`hex_outcomes` and
+                       :meth:`int_outcomes` also do not work.
+
+            time_taken (float): The duration of the experiment that generated
+                the counts in seconds.
+            creg_sizes (list): a nested list where the inner element is a list
+                of tuples containing both the classical register name and
+                classical register size. For example,
+                ``[('c_reg', 2), ('my_creg', 4)]``.
+            memory_slots (int): The number of total ``memory_slots`` in the
+                experiment.
+        Raises:
+            TypeError: If the input key type is not an ``int`` or ``str``.
+            QiskitError: If a dit string key is input with ``creg_sizes`` and/or
+                ``memory_slots``.
+        """
+        bin_data = None
+        data = dict(data)
+        if not data:
+            self.int_raw = {}
+            self.hex_raw = {}
+            bin_data = {}
+        else:
+            first_key = next(iter(data.keys()))
+            if isinstance(first_key, int):
+                self.int_raw = data
+                self.hex_raw = {hex(key): value for key, value in self.int_raw.items()}
+            elif isinstance(first_key, str):
+                if first_key.startswith("0x"):
+                    self.hex_raw = data
+                    self.int_raw = {int(key, 0): value for key, value in self.hex_raw.items()}
+                elif first_key.startswith("0b"):
+                    self.int_raw = {int(key, 0): value for key, value in data.items()}
+                    self.hex_raw = {hex(key): value for key, value in self.int_raw.items()}
+                else:
+                    if not creg_sizes and not memory_slots:
+                        self.hex_raw = None
+                        self.int_raw = None
+                        bin_data = data
+                    else:
+                        hex_dict = {}
+                        int_dict = {}
+                        for bitstring, value in data.items():
+                            if not self.bitstring_regex.search(bitstring):
+                                raise exceptions.QiskitError(
+                                    "Counts objects with dit strings do not "
+                                    "currently support dit string formatting parameters "
+                                    "creg_sizes or memory_slots"
+                                )
+                            int_key = self._remove_space_underscore(bitstring)
+                            int_dict[int_key] = value
+                            hex_dict[hex(int_key)] = value
+                        self.hex_raw = hex_dict
+                        self.int_raw = int_dict
+            else:
+                raise TypeError(
+                    "Invalid input key type %s, must be either an int "
+                    "key or string key with hexademical value or bit string"
+                )
+        header = {}
+        self.creg_sizes = creg_sizes
+        if self.creg_sizes:
+            header["creg_sizes"] = self.creg_sizes
+        self.memory_slots = memory_slots
+        if self.memory_slots:
+            header["memory_slots"] = self.memory_slots
+        if not bin_data:
+            bin_data = postprocess.format_counts(self.hex_raw, header=header)
+        super().__init__(bin_data)
+        self.time_taken = time_taken
+
+    def most_frequent(self):
+        """Return the most frequent count
+
+        Returns:
+            str: The bit string for the most frequent result
+        Raises:
+            QiskitError: when there is >1 count with the same max counts, or
+                an empty object.
+        """
+        if not self:
+            raise exceptions.QiskitError("Can not return a most frequent count on an empty object")
+        max_value = max(self.values())
+        max_values_counts = [x[0] for x in self.items() if x[1] == max_value]
+        if len(max_values_counts) != 1:
+            raise exceptions.QiskitError(
+                "Multiple values have the same maximum counts: %s" % ",".join(max_values_counts)
+            )
+        return max_values_counts[0]
+
+    def hex_outcomes(self):
+        """Return a counts dictionary with hexadecimal string keys
+
+        Returns:
+            dict: A dictionary with the keys as hexadecimal strings instead of
+                bitstrings
+        Raises:
+            QiskitError: If the Counts object contains counts for dit strings
+        """
+        if self.hex_raw:
+            return {key.lower(): value for key, value in self.hex_raw.items()}
+        else:
+            out_dict = {}
+            for bitstring, value in self.items():
+                if not self.bitstring_regex.search(bitstring):
+                    raise exceptions.QiskitError(
+                        "Counts objects with dit strings do not "
+                        "currently support conversion to hexadecimal"
+                    )
+                int_key = self._remove_space_underscore(bitstring)
+                out_dict[hex(int_key)] = value
+            return out_dict
+
+    def int_outcomes(self):
+        """Build a counts dictionary with integer keys instead of count strings
+
+        Returns:
+            dict: A dictionary with the keys as integers instead of bitstrings
+        Raises:
+            QiskitError: If the Counts object contains counts for dit strings
+        """
+        if self.int_raw:
+            return self.int_raw
+        else:
+            out_dict = {}
+            for bitstring, value in self.items():
+                if not self.bitstring_regex.search(bitstring):
+                    raise exceptions.QiskitError(
+                        "Counts objects with dit strings do not "
+                        "currently support conversion to integer"
+                    )
+                int_key = self._remove_space_underscore(bitstring)
+                out_dict[int_key] = value
+            return out_dict
+
+    @staticmethod
+    def _remove_space_underscore(bitstring):
+        """Removes all spaces and underscores from bitstring"""
+        return int(bitstring.replace(" ", "").replace("_", ""), 2)
+
+    def shots(self):
+        """Return the number of shots"""
+        return sum(self.values())

qiskit/result/distributions/__init__.py

@@ -0,0 +1,17 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+"""
+Distributions
+"""
+from .probability import ProbDistribution
+from .quasi import QuasiDistribution

qiskit/result/distributions/probability.py

@@ -0,0 +1,100 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+"""Class for probability distributions."""
+
+import re
+
+
+# NOTE: A dict subclass should not overload any dunder methods like __getitem__
+# this can cause unexpected behavior and issues as the cPython dict
+# implementation has many standard methods in C for performance and the dunder
+# methods are not always used as expected. For example, update() doesn't call
+# __setitem__ so overloading __setitem__ would not always provide the expected
+# result
+class ProbDistribution(dict):
+    """A generic dict-like class for probability distributions."""
+
+    _bitstring_regex = re.compile(r"^[01]+$")
+
+    def __init__(self, data, shots=None):
+        """Builds a probability distribution object.
+
+        Args:
+            data (dict): Input probability data. Where the keys
+                represent a measured classical value and the value is a
+                float for the probability of that result.
+                The keys can be one of several formats:
+
+                    * A hexadecimal string of the form ``"0x4a"``
+                    * A bit string e.g. ``'0b1011'`` or ``"01011"``
+                    * An integer
+
+            shots (int): Number of shots the distribution was derived from.
+
+        Raises:
+            TypeError: If the input keys are not a string or int
+            ValueError: If the string format of the keys is incorrect
+        """
+        self.shots = shots
+        self._num_bits = 0
+        if data:
+            first_key = next(iter(data.keys()))
+            if isinstance(first_key, int):
+                # `self._num_bits` is not always the exact number of qubits measured,
+                # but the number of bits to represent the largest key.
+                self._num_bits = len(bin(max(data.keys()))) - 2
+            elif isinstance(first_key, str):
+                if first_key.startswith("0x") or first_key.startswith("0b"):
+                    data = {int(key, 0): value for key, value in data.items()}
+                    # `self._num_bits` is not always the exact number of qubits measured,
+                    # but the number of bits to represent the largest key.
+                    self._num_bits = len(bin(max(data.keys()))) - 2
+                elif self._bitstring_regex.search(first_key):
+                    # `self._num_bits` is the exact number of qubits measured.
+                    self._num_bits = max(len(key) for key in data)
+                    data = {int(key, 2): value for key, value in data.items()}
+                else:
+                    raise ValueError(
+                        "The input keys are not a valid string format, must either "
+                        "be a hex string prefixed by '0x' or a binary string "
+                        "optionally prefixed with 0b"
+                    )
+            else:
+                raise TypeError("Input data's keys are of invalid type, must be str or int")
+        super().__init__(data)
+
+    def binary_probabilities(self, num_bits=None):
+        """Build a probabilities dictionary with binary string keys
+
+        Parameters:
+            num_bits (int): number of bits in the binary bitstrings (leading
+                zeros will be padded). If None, a default value will be used.
+                If keys are given as integers or strings with binary or hex prefix,
+                the default value will be derived from the largest key present.
+                If keys are given as bitstrings without prefix,
+                the default value will be derived from the largest key length.
+
+        Returns:
+            dict: A dictionary where the keys are binary strings in the format
+                ``"0110"``
+        """
+        n = self._num_bits if num_bits is None else num_bits
+        return {format(key, "b").zfill(n): value for key, value in self.items()}
+
+    def hex_probabilities(self):
+        """Build a probabilities dictionary with hexadecimal string keys
+
+        Returns:
+            dict: A dictionary where the keys are hexadecimal strings in the
+                format ``"0x1a"``
+        """
+        return {hex(key): value for key, value in self.items()}