qiskit 1.4.1__cp39-abi3-win_amd64.whl → 2.0.0__cp39-abi3-win_amd64.whl

qiskit/circuit/library/data_preparation/initializer.py

@@ -19,7 +19,7 @@ from collections.abc import Sequence
 import typing
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.instruction import Instruction
 from qiskit.circuit.library.generalized_gates import Isometry
 from .state_preparation import StatePreparation

qiskit/circuit/library/data_preparation/pauli_feature_map.py

@@ -125,9 +125,9 @@ def pauli_feature_map(
         q_1: ┤ H ├────────────┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├─────────────
              └───┘            └───┘└────────────────────────────────┘└───┘
 
-        >>> from qiskit.circuit.library import EfficientSU2
+        >>> from qiskit.circuit.library import efficient_su2
         >>> prep = pauli_feature_map(3, reps=3, paulis=["Z", "YY", "ZXZ"])
-        >>> wavefunction = EfficientSU2(3)
+        >>> wavefunction = efficient_su2(3)
         >>> classifier = prep.compose(wavefunction)
         >>> classifier.num_parameters
         27
@@ -286,8 +286,8 @@ def zz_feature_map(
         q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├
              └───┘└─────────────┘└───┘└────────────────────────────────┘└───┘
 
-        >>> from qiskit.circuit.library import EfficientSU2
-        >>> classifier = zz_feature_map(3) + EfficientSU2(3)
+        >>> from qiskit.circuit.library import efficient_su2
+        >>> classifier = zz_feature_map(3).compose(efficient_su2(3))
         >>> classifier.num_parameters
         15
         >>> classifier.parameters  # 'x' for the data preparation, 'θ' for the SU2 parameters

qiskit/circuit/library/data_preparation/state_preparation.py

@@ -18,7 +18,7 @@ import numpy as np
 
 from qiskit.exceptions import QiskitError
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.library.standard_gates.x import XGate
 from qiskit.circuit.library.standard_gates.h import HGate

qiskit/circuit/library/generalized_gates/gms.py

@@ -20,7 +20,7 @@ from collections.abc import Sequence
 
 import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.parameterexpression import ParameterValueType
 from qiskit.circuit.library.standard_gates import RXXGate
 from qiskit.circuit.gate import Gate

qiskit/circuit/library/generalized_gates/isometry.py

@@ -26,7 +26,7 @@ import numpy as np
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.circuit.instruction import Instruction
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.exceptions import QiskitError
 from qiskit.quantum_info.operators.predicates import is_isometry
 from qiskit._accelerate import isometry as isometry_rs

qiskit/circuit/library/generalized_gates/pauli.py

@@ -14,7 +14,6 @@
 Simulator command to perform multiple pauli gates in a single pass
 """
 from qiskit.circuit.quantumcircuitdata import CircuitInstruction
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.library.standard_gates.x import XGate
 from qiskit.circuit.library.standard_gates.y import YGate
 from qiskit.circuit.library.standard_gates.z import ZGate
@@ -46,7 +45,7 @@ class PauliGate(Gate):
         gate pauli (p1 a1,...,pn an) { p1 a1; ... ; pn an; }
         """
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
 
         gates = {"X": XGate, "Y": YGate, "Z": ZGate}
         q = QuantumRegister(len(self.params[0]), "q")

qiskit/circuit/library/generalized_gates/uc.py

@@ -28,13 +28,13 @@ import numpy as np
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.library.standard_gates.h import HGate
 from qiskit.quantum_info.operators.predicates import is_unitary_matrix
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.exceptions import QiskitError
 from qiskit._accelerate import uc_gate
 
-from .diagonal import Diagonal
+from .diagonal import DiagonalGate
 
 _EPS = 1e-10  # global variable used to chop very small numbers to zero
 
@@ -60,14 +60,21 @@ class UCGate(Gate):
 
     The decomposition is based on Ref. [1].
 
+    Unnecessary controls and repeated operators can be removed as described in Ref [2].
+
     **References:**
 
     [1] Bergholm et al., Quantum circuits with uniformly controlled one-qubit gates (2005).
         `Phys. Rev. A 71, 052330 <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.71.052330>`__.
 
+    [2] de Carvalho et al., Quantum multiplexer simplification for state preparation (2024).
+        `arXiv:2409.05618 <https://arxiv.org/abs/2409.05618>`__.
+
     """
 
-    def __init__(self, gate_list: list[np.ndarray], up_to_diagonal: bool = False):
+    def __init__(
+        self, gate_list: list[np.ndarray], up_to_diagonal: bool = False, mux_simp: bool = True
+    ):
         r"""
         Args:
             gate_list: List of two qubit unitaries :math:`[U_0, ..., U_{2^{k-1}}]`, where each
@@ -76,6 +83,9 @@ class UCGate(Gate):
                 or if it is decomposed completely (default: False).
                 If the ``UCGate`` :math:`U` is decomposed up to a diagonal :math:`D`, this means
                 that the circuit implements a unitary :math:`U'` such that :math:`D U' = U`.
+            mux_simp: Determines whether the search for repetitions is conducted (default: True).
+                The intention is to perform a possible simplification in the number of controls
+                and operators.
 
         Raises:
             QiskitError: in case of bad input to the constructor
@@ -101,10 +111,67 @@ class UCGate(Gate):
             if not is_unitary_matrix(gate, _EPS):
                 raise QiskitError("A controlled gate is not unitary.")
 
+        new_controls = set()
+        if mux_simp:
+            new_controls, gate_list = self._simplify(gate_list, num_contr)
+        self.simp_contr = (mux_simp, new_controls)
+
         # Create new gate.
         super().__init__("multiplexer", int(num_contr) + 1, gate_list)
         self.up_to_diagonal = up_to_diagonal
 
+    def _simplify(self, gate_list, num_contr):
+        """https://arxiv.org/abs/2409.05618"""
+
+        c = set()
+        nc = set()
+        mux_copy = gate_list.copy()
+
+        for i in range(int(num_contr)):
+            c.add(i + 1)
+
+        if len(gate_list) > 1:
+            nc, mux_copy = self._repetition_search(gate_list, num_contr, mux_copy)
+
+        new_controls = {x for x in c if x not in nc}
+        new_mux = [gate for gate in mux_copy if gate is not None]
+        return new_controls, new_mux
+
+    def _repetition_search(self, mux, level, mux_copy):
+        nc = set()
+        d = 1
+        while d <= len(mux) / 2:
+            disentanglement = False
+            if np.allclose(mux[d], mux[0]):
+                mux_org = mux_copy.copy()
+                repetitions = len(mux) / (2 * d)
+                p = 0
+                while repetitions > 0:
+                    repetitions -= 1
+                    valid, mux_copy = self._repetition_verify(p, d, mux, mux_copy)
+                    p = p + 2 * d
+                    if not valid:
+                        mux_copy = mux_org
+                        break
+                    if repetitions == 0:
+                        disentanglement = True
+
+            if disentanglement:
+                removed_contr = level - math.log2(d)
+                nc.add(removed_contr)
+            d = 2 * d
+        return nc, mux_copy
+
+    def _repetition_verify(self, base, d, mux, mux_copy):
+        i = 0
+        next_base = base + d
+        while i < d:
+            if not np.allclose(mux[base], mux[next_base]):
+                return False, mux_copy
+            mux_copy[next_base] = None
+            base, next_base, i = base + 1, next_base + 1, i + 1
+        return True, mux_copy
+
     def inverse(self, annotated: bool = False) -> Gate:
         """Return the inverse.
 
@@ -135,6 +202,19 @@ class UCGate(Gate):
         # q[k-1],...,q[0],q_target, decreasingly ordered with respect to the
         # significance of the qubit in the computational basis
         _, diag = self._dec_ucg()
+        if self.simp_contr[1]:
+            q_controls = [self.num_qubits - i for i in self.simp_contr[1]]
+            q_controls.reverse()
+            for i in range(self.num_qubits):
+                if i not in [0] + q_controls:
+                    d = 2**i
+                    new_diag = []
+                    n = len(diag)
+                    for j in range(n):
+                        new_diag.append(diag[j])
+                        if (j + 1) % d == 0:
+                            new_diag.extend(diag[j + 1 - d : j + 1])
+                    diag = np.array(new_diag)
         return diag
 
     def _define(self):
@@ -149,12 +229,19 @@ class UCGate(Gate):
         """
         diag = np.ones(2**self.num_qubits).tolist()
         q = QuantumRegister(self.num_qubits, "q")
-        q_controls = q[1:]
         q_target = q[0]
+        mux_simplify = self.simp_contr[0]
+
+        if mux_simplify:
+            q_controls = [q[self.num_qubits - i] for i in self.simp_contr[1]]
+            q_controls.reverse()
+        else:
+            q_controls = q[1:]
+
         circuit = QuantumCircuit(q, name="uc")
         # If there is no control, we use the ZYZ decomposition
         if not q_controls:
-            circuit.unitary(self.params[0], [q])
+            circuit.unitary(self.params[0], q[0])
             return circuit, diag
         # If there is at least one control, first,
         # we find the single qubit gates of the decomposition.
@@ -189,8 +276,9 @@ class UCGate(Gate):
             # Important: the diagonal gate is given in the computational basis of the qubits
             # q[k-1],...,q[0],q_target (ordered with decreasing significance),
             # where q[i] are the control qubits and t denotes the target qubit.
-            diagonal = Diagonal(diag)
-            circuit.append(diagonal, q)
+            diagonal = DiagonalGate(diag)
+
+            circuit.append(diagonal, [q_target] + q_controls)
         return circuit, diag
 
     def _dec_ucg_help(self):
@@ -199,6 +287,8 @@ class UCGate(Gate):
         https://arxiv.org/pdf/quant-ph/0410066.pdf.
         """
         single_qubit_gates = [gate.astype(complex) for gate in self.params]
+        if self.simp_contr[0]:
+            return uc_gate.dec_ucg_help(single_qubit_gates, len(self.simp_contr[1]) + 1)
         return uc_gate.dec_ucg_help(single_qubit_gates, self.num_qubits)
 
     @staticmethod

qiskit/circuit/library/generalized_gates/uc_pauli_rot.py

@@ -23,7 +23,7 @@ import numpy as np
 
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.exceptions import QiskitError
 
 _EPS = 1e-10  # global variable used to chop very small numbers to zero

qiskit/circuit/library/generalized_gates/unitary.py

@@ -23,7 +23,7 @@ from qiskit.circuit.gate import Gate
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.annotated_operation import AnnotatedOperation, ControlModifier
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.circuit._utils import _compute_control_matrix
 from qiskit.circuit.library.standard_gates.u import UGate
@@ -45,7 +45,9 @@ class UnitaryGate(Gate):
         quantum circuit. The matrix can also be directly applied to the quantum
         circuit, see :meth:`.QuantumCircuit.unitary`.
 
-        .. code-block:: python
+        .. plot::
+           :include-source:
+           :nofigs:
 
             from qiskit import QuantumCircuit
             from qiskit.circuit.library import UnitaryGate

qiskit/circuit/library/graph_state.py

@@ -48,6 +48,7 @@ class GraphState(QuantumCircuit):
        import rustworkx as rx
        G = rx.generators.cycle_graph(5)
        circuit = GraphState(rx.adjacency_matrix(G))
+       circuit.name = "Graph state"
        _generate_circuit_library_visualization(circuit)
 
     **References:**

qiskit/circuit/library/hamiltonian_gate.py

@@ -24,7 +24,7 @@ import numpy as np
 from qiskit import _numpy_compat
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.parameterexpression import ParameterExpression
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.quantum_info.operators.predicates import matrix_equal

qiskit/circuit/library/n_local/evolved_operator_ansatz.py

@@ -23,7 +23,7 @@ import numpy as np
 from qiskit.circuit.library.pauli_evolution import PauliEvolutionGate
 from qiskit.circuit.parameter import Parameter
 from qiskit.circuit.parametervector import ParameterVector
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.quantum_info import Operator, Pauli, SparsePauliOp
 from qiskit.quantum_info.operators.base_operator import BaseOperator

qiskit/circuit/library/n_local/n_local.py

@@ -23,7 +23,7 @@ import numpy
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.quantumcircuit import QuantumCircuit, ParameterValueType
 from qiskit.circuit.parametervector import ParameterVector, ParameterVectorElement
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit import (
     Instruction,
     Parameter,

qiskit/circuit/library/n_local/qaoa_ansatz.py

@@ -19,7 +19,7 @@ import numpy as np
 
 from qiskit.circuit.parametervector import ParameterVector
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.quantum_info import SparsePauliOp
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 

qiskit/circuit/library/overlap.py

@@ -132,10 +132,10 @@ def unitary_overlap(
         :include-source:
 
         import numpy as np
-        from qiskit.circuit.library import EfficientSU2, unitary_overlap
+        from qiskit.circuit.library import efficient_su2, unitary_overlap
 
         # get two circuit to prepare states of which we compute the overlap
-        circuit = EfficientSU2(2, reps=1)
+        circuit = efficient_su2(2, reps=1)
         unitary1 = circuit.assign_parameters(np.random.random(circuit.num_parameters))
         unitary2 = circuit.assign_parameters(np.random.random(circuit.num_parameters))
 

qiskit/circuit/library/pauli_evolution.py

@@ -20,7 +20,7 @@ import numpy as np
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.quantumcircuit import ParameterValueType
 from qiskit.circuit.parameterexpression import ParameterExpression
-from qiskit.quantum_info import Pauli, SparsePauliOp
+from qiskit.quantum_info import Pauli, SparsePauliOp, SparseObservable
 
 if TYPE_CHECKING:
     from qiskit.synthesis.evolution import EvolutionSynthesis
@@ -49,7 +49,9 @@ class PauliEvolutionGate(Gate):
 
     **Examples:**
 
-    .. code-block:: python
+    .. plot::
+       :include-source:
+       :nofigs:
 
         from qiskit.circuit import QuantumCircuit
         from qiskit.circuit.library import PauliEvolutionGate
@@ -68,7 +70,9 @@ class PauliEvolutionGate(Gate):
         circuit.append(evo, range(2))
         print(circuit.draw())
 
-    The above will print (note that the ``-0.1`` coefficient is not printed!)::
+    The above will print (note that the ``-0.1`` coefficient is not printed!):
+
+    .. code-block:: text
 
              ┌──────────────────────────┐
         q_0: ┤0                         ├
@@ -86,15 +90,19 @@ class PauliEvolutionGate(Gate):
 
     def __init__(
         self,
-        operator: Pauli | SparsePauliOp | list[Pauli | SparsePauliOp],
+        operator: (
+            Pauli
+            | SparsePauliOp
+            | SparseObservable
+            | list[Pauli | SparsePauliOp | SparseObservable]
+        ),
         time: ParameterValueType = 1.0,
         label: str | None = None,
         synthesis: EvolutionSynthesis | None = None,
     ) -> None:
         """
         Args:
-            operator (Pauli | SparsePauliOp | list):
-                The operator to evolve. Can also be provided as list of non-commuting
+            operator: The operator to evolve. Can also be provided as list of non-commuting
                 operators where the elements are sums of commuting operators.
                 For example: ``[XY + YX, ZZ + ZI + IZ, YY]``.
             time: The evolution time.
@@ -106,9 +114,9 @@ class PauliEvolutionGate(Gate):
                 product formula with a single repetition.
         """
         if isinstance(operator, list):
-            operator = [_to_sparse_pauli_op(op) for op in operator]
+            operator = [_to_sparse_op(op) for op in operator]
         else:
-            operator = _to_sparse_pauli_op(operator)
+            operator = _to_sparse_op(operator)
 
         if label is None:
             label = _get_default_label(operator)
@@ -155,32 +163,39 @@ class PauliEvolutionGate(Gate):
         return super().validate_parameter(parameter)
 
 
-def _to_sparse_pauli_op(operator):
+def _to_sparse_op(
+    operator: Pauli | SparsePauliOp | SparseObservable,
+) -> SparsePauliOp | SparseObservable:
     """Cast the operator to a SparsePauliOp."""
 
     if isinstance(operator, Pauli):
-        sparse_pauli = SparsePauliOp(operator)
-    elif isinstance(operator, SparsePauliOp):
-        sparse_pauli = operator
+        sparse = SparsePauliOp(operator)
+    elif isinstance(operator, (SparseObservable, SparsePauliOp)):
+        sparse = operator
     else:
         raise ValueError(f"Unsupported operator type for evolution: {type(operator)}.")
 
-    if any(np.iscomplex(sparse_pauli.coeffs)):
+    if any(np.iscomplex(sparse.coeffs)):
         raise ValueError("Operator contains complex coefficients, which are not supported.")
-    if any(isinstance(coeff, ParameterExpression) for coeff in sparse_pauli.coeffs):
+    if any(isinstance(coeff, ParameterExpression) for coeff in sparse.coeffs):
         raise ValueError("Operator contains ParameterExpression, which are not supported.")
 
-    return sparse_pauli
+    return sparse
+
+
+def _operator_label(operator):
+    if isinstance(operator, SparseObservable):
+        if len(operator) == 1:
+            return operator[0].bit_labels()[::-1]
+        return "(" + " + ".join(term.bit_labels()[::-1] for term in operator) + ")"
+
+    # else: is a SparsePauliOp
+    if len(operator.paulis) == 1:
+        return operator.paulis.to_labels()[0]
+    return "(" + " + ".join(operator.paulis.to_labels()) + ")"
 
 
 def _get_default_label(operator):
     if isinstance(operator, list):
-        label = f"exp(-it ({[' + '.join(op.paulis.to_labels()) for op in operator]}))"
-    else:
-        if len(operator.paulis) == 1:
-            label = f"exp(-it {operator.paulis.to_labels()[0]})"
-        # for just a single Pauli don't add brackets around the sum
-        else:
-            label = f"exp(-it ({' + '.join(operator.paulis.to_labels())}))"
-
-    return label
+        return f"exp(-it ({[_operator_label(op) for op in operator]}))"
+    return f"exp(-it {_operator_label(operator)})"