qiskit 1.0.2__cp38-abi3-macosx_11_0_arm64.whl → 1.1.0rc1__cp38-abi3-macosx_11_0_arm64.whl

qiskit/quantum_info/states/densitymatrix.py

@@ -15,10 +15,11 @@ DensityMatrix quantum state class.
 """
 
 from __future__ import annotations
-import copy
+import copy as _copy
 from numbers import Number
 import numpy as np
 
+from qiskit import _numpy_compat
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.instruction import Instruction
 from qiskit.exceptions import QiskitError
@@ -110,10 +111,9 @@ class DensityMatrix(QuantumState, TolerancesMixin):
             raise QiskitError("Invalid DensityMatrix input: not a square matrix.")
         super().__init__(op_shape=OpShape.auto(shape=self._data.shape, dims_l=dims, dims_r=dims))
 
-    def __array__(self, dtype=None):
-        if dtype:
-            return np.asarray(self.data, dtype=dtype)
-        return self.data
+    def __array__(self, dtype=None, copy=_numpy_compat.COPY_ONLY_IF_NEEDED):
+        dtype = self.data.dtype if dtype is None else dtype
+        return np.array(self.data, dtype=dtype, copy=copy)
 
     def __eq__(self, other):
         return super().__eq__(other) and np.allclose(
@@ -241,7 +241,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
         """
         if not isinstance(other, DensityMatrix):
             other = DensityMatrix(other)
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = np.kron(self._data, other._data)
         ret._op_shape = self._op_shape.tensor(other._op_shape)
         return ret
@@ -260,7 +260,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
         """
         if not isinstance(other, DensityMatrix):
             other = DensityMatrix(other)
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = np.kron(other._data, self._data)
         ret._op_shape = self._op_shape.expand(other._op_shape)
         return ret
@@ -281,7 +281,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
         if not isinstance(other, DensityMatrix):
             other = DensityMatrix(other)
         self._op_shape._validate_add(other._op_shape)
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = self.data + other.data
         return ret
 
@@ -299,7 +299,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
         """
         if not isinstance(other, Number):
             raise QiskitError("other is not a number")
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = other * self.data
         return ret
 
@@ -356,7 +356,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
         Returns:
             DensityMatrix: the state with reversed subsystem order.
         """
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         axes = tuple(range(self._op_shape._num_qargs_l - 1, -1, -1))
         axes = axes + tuple(len(axes) + i for i in axes)
         ret._data = np.reshape(
@@ -523,7 +523,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
         """
         if qargs is None:
             # Resetting all qubits does not require sampling or RNG
-            ret = copy.copy(self)
+            ret = _copy.copy(self)
             state = np.zeros(self._op_shape.shape, dtype=complex)
             state[0, 0] = 1
             ret._data = state
@@ -715,7 +715,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
         new_shape._dims_r = new_shape._dims_l
         new_shape._num_qargs_r = new_shape._num_qargs_l
 
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         if qargs is None:
             # Evolution on full matrix
             op_mat = other.data
@@ -792,7 +792,7 @@ class DensityMatrix(QuantumState, TolerancesMixin):
         """Return a new statevector by applying an instruction."""
         if isinstance(obj, QuantumCircuit):
             obj = obj.to_instruction()
-        vec = copy.copy(self)
+        vec = _copy.copy(self)
         vec._append_instruction(obj, qargs=qargs)
         return vec
 

qiskit/quantum_info/states/stabilizerstate.py

@@ -415,7 +415,7 @@ class StabilizerState(QuantumState):
         outcome_prob = 1.0
         probs = {}  # probabilities dictionary
 
-        self._get_probablities(qubits, outcome, outcome_prob, probs)
+        self._get_probabilities(qubits, outcome, outcome_prob, probs)
 
         if decimals is not None:
             for key, value in probs.items():
@@ -644,7 +644,7 @@ class StabilizerState(QuantumState):
     # -----------------------------------------------------------------------
     # Helper functions for calculating the probabilities
     # -----------------------------------------------------------------------
-    def _get_probablities(self, qubits, outcome, outcome_prob, probs):
+    def _get_probabilities(self, qubits, outcome, outcome_prob, probs):
         """Recursive helper function for calculating the probabilities"""
 
         qubit_for_branching = -1
@@ -679,4 +679,4 @@ class StabilizerState(QuantumState):
             stab_cpy._measure_and_update(
                 qubits[len(qubits) - qubit_for_branching - 1], single_qubit_outcome
             )
-            stab_cpy._get_probablities(qubits, new_outcome, 0.5 * outcome_prob, probs)
+            stab_cpy._get_probabilities(qubits, new_outcome, 0.5 * outcome_prob, probs)

qiskit/quantum_info/states/statevector.py

@@ -14,12 +14,14 @@
 Statevector quantum state class.
 """
 from __future__ import annotations
-import copy
+import copy as _copy
+import math
 import re
 from numbers import Number
 
 import numpy as np
 
+from qiskit import _numpy_compat
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.instruction import Instruction
 from qiskit.exceptions import QiskitError
@@ -103,10 +105,9 @@ class Statevector(QuantumState, TolerancesMixin):
                 raise QiskitError("Invalid input: not a vector or column-vector.")
         super().__init__(op_shape=OpShape.auto(shape=shape, dims_l=dims, num_qubits_r=0))
 
-    def __array__(self, dtype=None):
-        if dtype:
-            return np.asarray(self.data, dtype=dtype)
-        return self.data
+    def __array__(self, dtype=None, copy=_numpy_compat.COPY_ONLY_IF_NEEDED):
+        dtype = self.data.dtype if dtype is None else dtype
+        return np.array(self.data, dtype=dtype, copy=copy)
 
     def __eq__(self, other):
         return super().__eq__(other) and np.allclose(
@@ -276,7 +277,7 @@ class Statevector(QuantumState, TolerancesMixin):
         """
         if not isinstance(other, Statevector):
             other = Statevector(other)
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._op_shape = self._op_shape.tensor(other._op_shape)
         ret._data = np.kron(self._data, other._data)
         return ret
@@ -317,7 +318,7 @@ class Statevector(QuantumState, TolerancesMixin):
         """
         if not isinstance(other, Statevector):
             other = Statevector(other)
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._op_shape = self._op_shape.expand(other._op_shape)
         ret._data = np.kron(other._data, self._data)
         return ret
@@ -338,7 +339,7 @@ class Statevector(QuantumState, TolerancesMixin):
         if not isinstance(other, Statevector):
             other = Statevector(other)
         self._op_shape._validate_add(other._op_shape)
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = self.data + other.data
         return ret
 
@@ -356,7 +357,7 @@ class Statevector(QuantumState, TolerancesMixin):
         """
         if not isinstance(other, Number):
             raise QiskitError("other is not a number")
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = other * self.data
         return ret
 
@@ -381,7 +382,7 @@ class Statevector(QuantumState, TolerancesMixin):
             qargs = getattr(other, "qargs", None)
 
         # Get return vector
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
 
         # Evolution by a circuit or instruction
         if isinstance(other, QuantumCircuit):
@@ -447,7 +448,7 @@ class Statevector(QuantumState, TolerancesMixin):
         Returns:
             Statevector: the Statevector with reversed subsystem order.
         """
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         axes = tuple(range(self._op_shape._num_qargs_l - 1, -1, -1))
         ret._data = np.reshape(
             np.transpose(np.reshape(self.data, self._op_shape.tensor_shape), axes),
@@ -618,7 +619,7 @@ class Statevector(QuantumState, TolerancesMixin):
         """
         if qargs is None:
             # Resetting all qubits does not require sampling or RNG
-            ret = copy.copy(self)
+            ret = _copy.copy(self)
             state = np.zeros(self._op_shape.shape, dtype=complex)
             state[0] = 1
             ret._data = state
@@ -702,7 +703,7 @@ class Statevector(QuantumState, TolerancesMixin):
         state = Statevector(data)
         if xy_states:
             # Apply hadamards to all qubits in X eigenstates
-            x_mat = np.array([[1, 1], [1, -1]], dtype=complex) / np.sqrt(2)
+            x_mat = np.array([[1, 1], [1, -1]], dtype=complex) / math.sqrt(2)
             # Apply S.H to qubits in Y eigenstates
             y_mat = np.dot(np.diag([1, 1j]), x_mat)
             for qubit, char in enumerate(reversed(label)):

qiskit/quantum_info/states/utils.py

@@ -15,6 +15,7 @@ Quantum information utility functions for states.
 """
 
 from __future__ import annotations
+import math
 
 import numpy as np
 
@@ -102,17 +103,18 @@ def shannon_entropy(pvec: list | np.ndarray, base: int = 2) -> float:
     if base == 2:
 
         def logfn(x):
-            return -x * np.log2(x)
+            return -x * math.log2(x)
 
     elif base == np.e:
 
         def logfn(x):
-            return -x * np.log(x)
+            return -x * math.log(x)
 
     else:
+        log_base = math.log(base)
 
         def logfn(x):
-            return -x * np.log(x) / np.log(base)
+            return -x * math.log(x) / log_base
 
     h_val = 0.0
     for x in pvec:

qiskit/result/mitigation/correlated_readout_mitigator.py

@@ -13,6 +13,7 @@
 Readout mitigator class based on the A-matrix inversion method
 """
 
+import math
 from typing import Optional, List, Tuple, Iterable, Callable, Union, Dict
 import numpy as np
 
@@ -46,7 +47,7 @@ class CorrelatedReadoutMitigator(BaseReadoutMitigator):
         if np.any(assignment_matrix < 0) or not np.allclose(np.sum(assignment_matrix, axis=0), 1):
             raise QiskitError("Assignment matrix columns must be valid probability distributions")
         assignment_matrix = np.asarray(assignment_matrix, dtype=float)
-        matrix_qubits_num = int(np.log2(assignment_matrix.shape[0]))
+        matrix_qubits_num = int(math.log2(assignment_matrix.shape[0]))
         if qubits is None:
             self._num_qubits = matrix_qubits_num
             self._qubits = range(self._num_qubits)
@@ -260,7 +261,7 @@ class CorrelatedReadoutMitigator(BaseReadoutMitigator):
             float: the standard deviation upper bound.
         """
         gamma = self._compute_gamma()
-        return gamma / np.sqrt(shots)
+        return gamma / math.sqrt(shots)
 
     @property
     def qubits(self) -> Tuple[int]:

qiskit/result/mitigation/local_readout_mitigator.py

@@ -14,6 +14,7 @@ Readout mitigator class based on the 1-qubit local tensored mitigation method
 """
 
 
+import math
 from typing import Optional, List, Tuple, Iterable, Callable, Union, Dict
 import numpy as np
 
@@ -288,7 +289,7 @@ class LocalReadoutMitigator(BaseReadoutMitigator):
             float: the standard deviation upper bound.
         """
         gamma = self._compute_gamma(qubits=qubits)
-        return gamma / np.sqrt(shots)
+        return gamma / math.sqrt(shots)
 
     def _from_backend(self, backend, qubits):
         """Calculates amats from backend properties readout_error"""

qiskit/result/mitigation/utils.py

@@ -14,6 +14,7 @@ Readout mitigation data handling utils
 """
 
 import logging
+import math
 from typing import Optional, List, Tuple, Dict
 import numpy as np
 
@@ -55,7 +56,7 @@ def expval_with_stddev(coeffs: np.ndarray, probs: np.ndarray, shots: int) -> Tup
             "(%f). Setting standard deviation of result to 0.",
             variance,
         )
-    calc_stddev = np.sqrt(variance) if variance > 0 else 0.0
+    calc_stddev = math.sqrt(variance) if variance > 0 else 0.0
     return [expval, calc_stddev]
 
 
@@ -63,7 +64,7 @@ def stddev(probs, shots):
     """Calculate stddev dict"""
     ret = {}
     for key, prob in probs.items():
-        std_err = np.sqrt(prob * (1 - prob) / shots)
+        std_err = math.sqrt(prob * (1 - prob) / shots)
         ret[key] = std_err
     return ret
 

qiskit/synthesis/__init__.py

@@ -51,6 +51,7 @@ Permutation Synthesis
 .. autofunction:: synth_permutation_depth_lnn_kms
 .. autofunction:: synth_permutation_basic
 .. autofunction:: synth_permutation_acg
+.. autofunction:: synth_permutation_reverse_lnn_kms
 
 Clifford Synthesis
 ==================
@@ -140,6 +141,7 @@ from .permutation import (
     synth_permutation_depth_lnn_kms,
     synth_permutation_basic,
     synth_permutation_acg,
+    synth_permutation_reverse_lnn_kms,
 )
 from .linear import (
     synth_cnot_count_full_pmh,

qiskit/synthesis/discrete_basis/commutator_decompose.py

@@ -92,8 +92,8 @@ def _solve_decomposition_angle(matrix: np.ndarray) -> float:
     lhs = math.sin(angle / 2)
 
     def objective(phi):
-        sin_sq = np.sin(phi / 2) ** 2
-        return 2 * sin_sq * np.sqrt(1 - sin_sq**2) - lhs
+        sin_sq = math.sin(phi.item() / 2) ** 2
+        return 2 * sin_sq * math.sqrt(1 - sin_sq**2) - lhs
 
     decomposition_angle = fsolve(objective, angle)[0]
     return decomposition_angle

qiskit/synthesis/evolution/lie_trotter.py

@@ -76,7 +76,6 @@ class LieTrotter(ProductFormula):
 
         # construct the evolution circuit
         evolution_circuit = QuantumCircuit(operators[0].num_qubits)
-        first_barrier = False
 
         if not isinstance(operators, list):
             pauli_list = [(Pauli(op), np.real(coeff)) for op, coeff in operators.to_list()]
@@ -86,20 +85,14 @@ class LieTrotter(ProductFormula):
         # if we only evolve a single Pauli we don't need to additionally wrap it
         wrap = not (len(pauli_list) == 1 and self.reps == 1)
 
-        for _ in range(self.reps):
-            for op, coeff in pauli_list:
-                # add barriers
-                if first_barrier:
-                    if self.insert_barriers:
-                        evolution_circuit.barrier()
-                else:
-                    first_barrier = True
-
-                evolution_circuit.compose(
-                    self.atomic_evolution(op, coeff * time / self.reps), wrap=wrap, inplace=True
-                )
+        for i, (op, coeff) in enumerate(pauli_list):
+            evolution_circuit.compose(
+                self.atomic_evolution(op, coeff * time / self.reps), wrap=wrap, inplace=True
+            )
+            if self.insert_barriers and i != len(pauli_list) - 1:
+                evolution_circuit.barrier()
 
-        return evolution_circuit
+        return evolution_circuit.repeat(self.reps).decompose()
 
     @property
     def settings(self) -> Dict[str, Any]:

qiskit/synthesis/evolution/qdrift.py

@@ -12,6 +12,7 @@
 
 """QDrift Class"""
 
+import math
 from typing import Union, Optional, Callable
 import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit
@@ -73,7 +74,7 @@ class QDrift(ProductFormula):
         weights = np.abs(coeffs)
         lambd = np.sum(weights)
 
-        num_gates = int(np.ceil(2 * (lambd**2) * (time**2) * self.reps))
+        num_gates = math.ceil(2 * (lambd**2) * (time**2) * self.reps)
         # The protocol calls for the removal of the individual coefficients,
         # and multiplication by a constant evolution time.
         evolution_time = lambd * time / num_gates
@@ -83,8 +84,6 @@ class QDrift(ProductFormula):
             size=(num_gates,),
             p=weights / lambd,
         )
-        # Update the coefficients of sampled_ops
-        self.sampled_ops = [(op, evolution_time) for op, coeff in self.sampled_ops]
 
         # pylint: disable=cyclic-import
         from qiskit.circuit.library.pauli_evolution import PauliEvolutionGate
@@ -94,7 +93,7 @@ class QDrift(ProductFormula):
             insert_barriers=self.insert_barriers, atomic_evolution=self.atomic_evolution
         )
         evolution_circuit = PauliEvolutionGate(
-            sum(SparsePauliOp(op) for op, coeff in self.sampled_ops),
+            sum(SparsePauliOp(np.sign(coeff) * op) for op, coeff in self.sampled_ops),
             time=evolution_time,
             synthesis=lie_trotter,
         ).definition

qiskit/synthesis/linear/cnot_synth.py

@@ -37,9 +37,7 @@ def synth_cnot_count_full_pmh(
     Args:
         state: :math:`n \\times n` boolean invertible matrix, describing
             the state of the input circuit
-        section_size: The size of each section, used in the
-            Patel–Markov–Hayes algorithm [1]. ``section_size`` must be a factor of the number
-            of qubits.
+        section_size: The size of each section in the Patel–Markov–Hayes algorithm [1].
 
     Returns:
         QuantumCircuit: a CX-only circuit implementing the linear transformation.

qiskit/synthesis/linear/linear_circuits_utils.py

@@ -15,7 +15,7 @@
 import copy
 from typing import Callable
 import numpy as np
-from qiskit import QuantumCircuit
+from qiskit.circuit import QuantumCircuit
 from qiskit.exceptions import QiskitError
 from qiskit.circuit.exceptions import CircuitError
 from . import calc_inverse_matrix, check_invertible_binary_matrix

qiskit/synthesis/linear_phase/cz_depth_lnn.py

@@ -24,24 +24,10 @@ References:
 
 import numpy as np
 from qiskit.circuit import QuantumCircuit
-
-
-def _append_cx_stage1(qc, n):
-    """A single layer of CX gates."""
-    for i in range(n // 2):
-        qc.cx(2 * i, 2 * i + 1)
-    for i in range((n + 1) // 2 - 1):
-        qc.cx(2 * i + 2, 2 * i + 1)
-    return qc
-
-
-def _append_cx_stage2(qc, n):
-    """A single layer of CX gates."""
-    for i in range(n // 2):
-        qc.cx(2 * i + 1, 2 * i)
-    for i in range((n + 1) // 2 - 1):
-        qc.cx(2 * i + 1, 2 * i + 2)
-    return qc
+from qiskit.synthesis.permutation.permutation_reverse_lnn import (
+    _append_cx_stage1,
+    _append_cx_stage2,
+)
 
 
 def _odd_pattern1(n):

qiskit/synthesis/permutation/__init__.py

@@ -15,3 +15,4 @@
 
 from .permutation_lnn import synth_permutation_depth_lnn_kms
 from .permutation_full import synth_permutation_basic, synth_permutation_acg
+from .permutation_reverse_lnn import synth_permutation_reverse_lnn_kms

qiskit/synthesis/permutation/permutation_reverse_lnn.py

@@ -0,0 +1,90 @@
+# 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.
+"""
+Synthesis of a reverse permutation for LNN connectivity.
+"""
+
+from qiskit.circuit import QuantumCircuit
+
+
+def _append_cx_stage1(qc, n):
+    """A single layer of CX gates."""
+    for i in range(n // 2):
+        qc.cx(2 * i, 2 * i + 1)
+    for i in range((n + 1) // 2 - 1):
+        qc.cx(2 * i + 2, 2 * i + 1)
+    return qc
+
+
+def _append_cx_stage2(qc, n):
+    """A single layer of CX gates."""
+    for i in range(n // 2):
+        qc.cx(2 * i + 1, 2 * i)
+    for i in range((n + 1) // 2 - 1):
+        qc.cx(2 * i + 1, 2 * i + 2)
+    return qc
+
+
+def _append_reverse_permutation_lnn_kms(qc: QuantumCircuit, num_qubits: int) -> None:
+    """
+    Append reverse permutation to a QuantumCircuit for linear nearest-neighbor architectures
+    using Kutin, Moulton, Smithline method.
+
+    Synthesis algorithm for reverse permutation from [1], section 5.
+    This algorithm synthesizes the reverse permutation on :math:`n` qubits over
+    a linear nearest-neighbor architecture using CX gates with depth :math:`2 * n + 2`.
+
+    Args:
+        qc: The original quantum circuit.
+        num_qubits: The number of qubits.
+
+    Returns:
+        The quantum circuit with appended reverse permutation.
+
+    References:
+        1. Kutin, S., Moulton, D. P., Smithline, L.,
+           *Computation at a distance*, Chicago J. Theor. Comput. Sci., vol. 2007, (2007),
+           `arXiv:quant-ph/0701194 <https://arxiv.org/abs/quant-ph/0701194>`_
+    """
+
+    for _ in range((num_qubits + 1) // 2):
+        _append_cx_stage1(qc, num_qubits)
+        _append_cx_stage2(qc, num_qubits)
+    if (num_qubits % 2) == 0:
+        _append_cx_stage1(qc, num_qubits)
+
+
+def synth_permutation_reverse_lnn_kms(num_qubits: int) -> QuantumCircuit:
+    """
+    Synthesize reverse permutation for linear nearest-neighbor architectures using
+    Kutin, Moulton, Smithline method.
+
+    Synthesis algorithm for reverse permutation from [1], section 5.
+    This algorithm synthesizes the reverse permutation on :math:`n` qubits over
+    a linear nearest-neighbor architecture using CX gates with depth :math:`2 * n + 2`.
+
+    Args:
+        num_qubits: The number of qubits.
+
+    Returns:
+        The synthesized quantum circuit.
+
+    References:
+        1. Kutin, S., Moulton, D. P., Smithline, L.,
+           *Computation at a distance*, Chicago J. Theor. Comput. Sci., vol. 2007, (2007),
+           `arXiv:quant-ph/0701194 <https://arxiv.org/abs/quant-ph/0701194>`_
+    """
+
+    qc = QuantumCircuit(num_qubits)
+    _append_reverse_permutation_lnn_kms(qc, num_qubits)
+
+    return qc

qiskit/synthesis/qft/qft_decompose_lnn.py

@@ -15,7 +15,7 @@ Circuit synthesis for a QFT circuit.
 
 import numpy as np
 from qiskit.circuit import QuantumCircuit
-from qiskit.synthesis.linear_phase.cz_depth_lnn import _append_cx_stage1, _append_cx_stage2
+from qiskit.synthesis.permutation.permutation_reverse_lnn import _append_reverse_permutation_lnn_kms
 
 
 def synth_qft_line(
@@ -65,10 +65,6 @@ def synth_qft_line(
     if not do_swaps:
         # Add a reversal network for LNN connectivity in depth 2*n+2,
         # based on Kutin at al., https://arxiv.org/abs/quant-ph/0701194, Section 5.
-        for _ in range((num_qubits + 1) // 2):
-            qc = _append_cx_stage1(qc, num_qubits)
-            qc = _append_cx_stage2(qc, num_qubits)
-        if (num_qubits % 2) == 0:
-            qc = _append_cx_stage1(qc, num_qubits)
+        _append_reverse_permutation_lnn_kms(qc, num_qubits)
 
     return qc