qiskit 1.2.0rc1__cp38-abi3-win32.whl → 1.2.2__cp38-abi3-win32.whl

qiskit/VERSION.txt

@@ -1 +1 @@
-1.2.0rc1
+1.2.2

qiskit/circuit/__init__.py

@@ -301,9 +301,10 @@ assist compilation workflows.  These include:
 * :data:`SessionEquivalenceLibrary`, a mutable instance of :class:`EquivalenceLibrary` which is used
   by default by the compiler's :class:`.BasisTranslator`.
 
-There is also a utility for generating random circuits:
+There are also utilities for generating random circuits:
 
-* :func:`random.random_circuit`
+* :func:`.random_circuit`
+* :func:`.random_clifford_circuit`
 
 Finally, the circuit module has its own exception class, to indicate when things went wrong in
 circuit-specific manners:
@@ -579,6 +580,16 @@ The :class:`Store` instruction is particularly special, in that it allows writin
 :class:`Qubit` nor :class:`Clbit` operands, but has an explicit :attr:`~Store.lvalue` and
 :attr:`~Store.rvalue`.
 
+For example, to determine the parity of a bitstring ``cr`` and store it in another register ``creg``,
+the :class:`Store` instruction can be used in the following way::
+
+    parity = expr.lift(cr[0])
+    for i in range(1,n):
+        parity = expr.bit_xor(cr[i], parity)
+    qc.store(creg[0], parity)
+
+
+
 .. autoclass:: Store
     :show-inheritance:
     :members:
@@ -1004,6 +1015,7 @@ Generating random circuits
 
 .. currentmodule:: qiskit.circuit.random
 .. autofunction:: random_circuit
+.. autofunction:: random_clifford_circuit
 .. currentmodule:: qiskit.circuit
 
 
@@ -1250,3 +1262,4 @@ from .controlflow import (
 )
 
 from .annotated_operation import AnnotatedOperation, InverseModifier, ControlModifier, PowerModifier
+from .random import random_circuit, random_clifford_circuit

qiskit/circuit/library/basis_change/qft.py

@@ -315,8 +315,10 @@ class QFTGate(Gate):
         """
         super().__init__(name="qft", num_qubits=num_qubits, params=[])
 
-    def __array__(self, dtype=complex):
+    def __array__(self, dtype=complex, copy=None):
         """Return a numpy array for the QFTGate."""
+        if copy is False:
+            raise ValueError("unable to avoid copy while creating an array as requested")
         n = self.num_qubits
         nums = np.arange(2**n)
         outer = np.outer(nums, nums)

qiskit/circuit/library/data_preparation/initializer.py

@@ -21,6 +21,7 @@ import typing
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.instruction import Instruction
+from qiskit.circuit.library.generalized_gates import Isometry
 from .state_preparation import StatePreparation
 
 if typing.TYPE_CHECKING:
@@ -86,9 +87,11 @@ class Initialize(Instruction):
         """Call to create a circuit with gates that take the desired vector to zero.
 
         Returns:
-            Circuit to take ``self.params`` vector to :math:`|{00\\ldots0}\\rangle`
+            QuantumCircuit: circuit to take ``self.params`` vector to :math:`|{00\\ldots0}\\rangle`
         """
-        return self._stateprep._gates_to_uncompute()
+
+        isom = Isometry(self.params, 0, 0)
+        return isom._gates_to_uncompute()
 
     @property
     def params(self):

qiskit/circuit/library/data_preparation/state_preparation.py

@@ -173,8 +173,8 @@ class StatePreparation(Gate):
         q = QuantumRegister(self.num_qubits, "q")
         initialize_circuit = QuantumCircuit(q, name="init_def")
 
-        isom = Isometry(self._params_arg, 0, 0)
-        initialize_circuit.append(isom, q[:])
+        isom = Isometry(self.params, 0, 0)
+        initialize_circuit.compose(isom.definition, copy=False, inplace=True)
 
         # invert the circuit to create the desired vector from zero (assuming
         # the qubits are in the zero state)

qiskit/circuit/library/pauli_evolution.py

@@ -56,6 +56,7 @@ class PauliEvolutionGate(Gate):
 
         X = SparsePauliOp("X")
         Z = SparsePauliOp("Z")
+        I = SparsePauliOp("I")
 
         # build the evolution gate
         operator = (Z ^ Z) - 0.1 * (X ^ I)

qiskit/circuit/library/standard_gates/__init__.py

@@ -54,6 +54,13 @@ def get_standard_gate_name_mapping():
     from qiskit.circuit.delay import Delay
     from qiskit.circuit.reset import Reset
 
+    lambda_ = Parameter("λ")
+    theta = Parameter("ϴ")
+    phi = Parameter("φ")
+    gamma = Parameter("γ")
+    beta = Parameter("β")
+    time = Parameter("t")
+
     # Standard gates library mapping, multicontrolled gates not included since they're
     # variable width
     gates = [
@@ -61,38 +68,37 @@ def get_standard_gate_name_mapping():
         SXGate(),
         XGate(),
         CXGate(),
-        RZGate(Parameter("λ")),
-        RGate(Parameter("ϴ"), Parameter("φ")),
-        Reset(),
+        RZGate(lambda_),
+        RGate(theta, phi),
         C3SXGate(),
         CCXGate(),
         DCXGate(),
         CHGate(),
-        CPhaseGate(Parameter("ϴ")),
-        CRXGate(Parameter("ϴ")),
-        CRYGate(Parameter("ϴ")),
-        CRZGate(Parameter("ϴ")),
+        CPhaseGate(theta),
+        CRXGate(theta),
+        CRYGate(theta),
+        CRZGate(theta),
         CSwapGate(),
         CSXGate(),
-        CUGate(Parameter("ϴ"), Parameter("φ"), Parameter("λ"), Parameter("γ")),
-        CU1Gate(Parameter("λ")),
-        CU3Gate(Parameter("ϴ"), Parameter("φ"), Parameter("λ")),
+        CUGate(theta, phi, lambda_, gamma),
+        CU1Gate(lambda_),
+        CU3Gate(theta, phi, lambda_),
         CYGate(),
         CZGate(),
         CCZGate(),
-        GlobalPhaseGate(Parameter("ϴ")),
+        GlobalPhaseGate(theta),
         HGate(),
-        PhaseGate(Parameter("ϴ")),
+        PhaseGate(theta),
         RCCXGate(),
         RC3XGate(),
-        RXGate(Parameter("ϴ")),
-        RXXGate(Parameter("ϴ")),
-        RYGate(Parameter("ϴ")),
-        RYYGate(Parameter("ϴ")),
-        RZZGate(Parameter("ϴ")),
-        RZXGate(Parameter("ϴ")),
-        XXMinusYYGate(Parameter("ϴ"), Parameter("β")),
-        XXPlusYYGate(Parameter("ϴ"), Parameter("β")),
+        RXGate(theta),
+        RXXGate(theta),
+        RYGate(theta),
+        RYYGate(theta),
+        RZZGate(theta),
+        RZXGate(theta),
+        XXMinusYYGate(theta, beta),
+        XXPlusYYGate(theta, beta),
         ECRGate(),
         SGate(),
         SdgGate(),
@@ -103,13 +109,14 @@ def get_standard_gate_name_mapping():
         SXdgGate(),
         TGate(),
         TdgGate(),
-        UGate(Parameter("ϴ"), Parameter("φ"), Parameter("λ")),
-        U1Gate(Parameter("λ")),
-        U2Gate(Parameter("φ"), Parameter("λ")),
-        U3Gate(Parameter("ϴ"), Parameter("φ"), Parameter("λ")),
+        UGate(theta, phi, lambda_),
+        U1Gate(lambda_),
+        U2Gate(phi, lambda_),
+        U3Gate(theta, phi, lambda_),
         YGate(),
         ZGate(),
-        Delay(Parameter("t")),
+        Delay(time),
+        Reset(),
         Measure(),
     ]
     name_mapping = {gate.name: gate for gate in gates}

qiskit/circuit/quantumcircuit.py

@@ -1152,17 +1152,41 @@ class QuantumCircuit:
         """The unit that :attr:`duration` is specified in."""
         self.metadata = {} if metadata is None else metadata
         """Arbitrary user-defined metadata for the circuit.
-
+ 
         Qiskit will not examine the content of this mapping, but it will pass it through the
         transpiler and reattach it to the output, so you can track your own metadata."""
 
     @classmethod
-    def _from_circuit_data(cls, data: CircuitData) -> typing.Self:
+    def _from_circuit_data(cls, data: CircuitData, add_regs: bool = False) -> typing.Self:
         """A private constructor from rust space circuit data."""
         out = QuantumCircuit()
+
+        if data.num_qubits > 0:
+            if add_regs:
+                qr = QuantumRegister(name="q", bits=data.qubits)
+                out.qregs = [qr]
+                out._qubit_indices = {
+                    bit: BitLocations(index, [(qr, index)]) for index, bit in enumerate(data.qubits)
+                }
+            else:
+                out._qubit_indices = {
+                    bit: BitLocations(index, []) for index, bit in enumerate(data.qubits)
+                }
+
+        if data.num_clbits > 0:
+            if add_regs:
+                cr = ClassicalRegister(name="c", bits=data.clbits)
+                out.cregs = [cr]
+                out._clbit_indices = {
+                    bit: BitLocations(index, [(cr, index)]) for index, bit in enumerate(data.clbits)
+                }
+            else:
+                out._clbit_indices = {
+                    bit: BitLocations(index, []) for index, bit in enumerate(data.clbits)
+                }
+
         out._data = data
-        out._qubit_indices = {bit: BitLocations(index, []) for index, bit in enumerate(data.qubits)}
-        out._clbit_indices = {bit: BitLocations(index, []) for index, bit in enumerate(data.clbits)}
+
         return out
 
     @staticmethod
@@ -3013,16 +3037,7 @@ class QuantumCircuit:
                         self._ancillas.append(bit)
 
             if isinstance(register, QuantumRegister):
-                self.qregs.append(register)
-
-                for idx, bit in enumerate(register):
-                    if bit in self._qubit_indices:
-                        self._qubit_indices[bit].registers.append((register, idx))
-                    else:
-                        self._data.add_qubit(bit)
-                        self._qubit_indices[bit] = BitLocations(
-                            self._data.num_qubits - 1, [(register, idx)]
-                        )
+                self._add_qreg(register)
 
             elif isinstance(register, ClassicalRegister):
                 self.cregs.append(register)
@@ -3041,6 +3056,16 @@ class QuantumCircuit:
             else:
                 raise CircuitError("expected a register")
 
+    def _add_qreg(self, qreg: QuantumRegister) -> None:
+        self.qregs.append(qreg)
+
+        for idx, bit in enumerate(qreg):
+            if bit in self._qubit_indices:
+                self._qubit_indices[bit].registers.append((qreg, idx))
+            else:
+                self._data.add_qubit(bit)
+                self._qubit_indices[bit] = BitLocations(self._data.num_qubits - 1, [(qreg, idx)])
+
     def add_bits(self, bits: Iterable[Bit]) -> None:
         """Add Bits to the circuit."""
         duplicate_bits = {
@@ -4188,7 +4213,7 @@ class QuantumCircuit:
     @overload
     def assign_parameters(
         self,
-        parameters: Union[Mapping[Parameter, ParameterValueType], Sequence[ParameterValueType]],
+        parameters: Union[Mapping[Parameter, ParameterValueType], Iterable[ParameterValueType]],
         inplace: Literal[False] = ...,
         *,
         flat_input: bool = ...,
@@ -4198,7 +4223,7 @@ class QuantumCircuit:
     @overload
     def assign_parameters(
         self,
-        parameters: Union[Mapping[Parameter, ParameterValueType], Sequence[ParameterValueType]],
+        parameters: Union[Mapping[Parameter, ParameterValueType], Iterable[ParameterValueType]],
         inplace: Literal[True] = ...,
         *,
         flat_input: bool = ...,
@@ -4207,7 +4232,7 @@ class QuantumCircuit:
 
     def assign_parameters(  # pylint: disable=missing-raises-doc
         self,
-        parameters: Union[Mapping[Parameter, ParameterValueType], Sequence[ParameterValueType]],
+        parameters: Union[Mapping[Parameter, ParameterValueType], Iterable[ParameterValueType]],
         inplace: bool = False,
         *,
         flat_input: bool = False,
@@ -4317,7 +4342,7 @@ class QuantumCircuit:
             target._data.assign_parameters_mapping(parameter_binds)
         else:
             parameter_binds = _ParameterBindsSequence(target._data.parameters, parameters)
-            target._data.assign_parameters_sequence(parameters)
+            target._data.assign_parameters_iterable(parameters)
 
         # Finally, assign the parameters inside any of the calibrations.  We don't track these in
         # the `ParameterTable`, so we manually reconstruct things.

qiskit/compiler/transpiler.py

@@ -23,7 +23,7 @@ from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.dagcircuit import DAGCircuit
 from qiskit.providers.backend import Backend
 from qiskit.providers.backend_compat import BackendV2Converter
-from qiskit.providers.models import BackendProperties
+from qiskit.providers.models.backendproperties import BackendProperties
 from qiskit.pulse import Schedule, InstructionScheduleMap
 from qiskit.transpiler import Layout, CouplingMap, PropertySet
 from qiskit.transpiler.basepasses import BasePass

qiskit/dagcircuit/dagcircuit.py

@@ -2090,7 +2090,7 @@ class DAGCircuit:
             new_layer = self.copy_empty_like(vars_mode=vars_mode)
 
             for node in op_nodes:
-                new_layer._apply_op_node_back(node, check=False)
+                new_layer._apply_op_node_back(copy.copy(node), check=False)
 
             # The quantum registers that have an operation in this layer.
             support_list = [

qiskit/primitives/base/base_estimator.py

@@ -92,7 +92,7 @@ class BaseEstimatorV1(BasePrimitive, Generic[T]):
         # calculate [ <psi1(theta1)|H1|psi1(theta1)> ]
         job = estimator.run([psi1], [H1], [theta1])
         job_result = job.result() # It will block until the job finishes.
-        print(f"The primitive-job finished with result {job_result}"))
+        print(f"The primitive-job finished with result {job_result}")
 
         # calculate [ <psi1(theta1)|H1|psi1(theta1)>,
         #             <psi2(theta2)|H2|psi2(theta2)>,
@@ -144,7 +144,7 @@ class BaseEstimatorV1(BasePrimitive, Generic[T]):
 
         .. code-block:: python
 
-            values = parameter_values[i].
+            values = parameter_values[i]
 
         Args:
             circuits: one or more circuit objects.

qiskit/primitives/containers/data_bin.py

@@ -34,14 +34,22 @@ class DataBin(ShapedMixin):
 
     .. code-block:: python
 
+        import numpy as np
+        from qiskit.primitives import DataBin, BitArray
+
         data = DataBin(
-            alpha=BitArray.from_bitstrings(["0010"]),
+            alpha=BitArray.from_samples(["0010"]),
             beta=np.array([1.2])
         )
 
         print("alpha data:", data.alpha)
         print("beta data:", data.beta)
 
+    .. code-block::
+
+        alpha data: BitArray(<shape=(), num_shots=1, num_bits=2>)
+        beta data: [1.2]
+
     """
 
     __slots__ = ("_data", "_shape")

qiskit/providers/basic_provider/basic_simulator.py

@@ -43,7 +43,7 @@ from qiskit.circuit.library import UnitaryGate
 from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping, GlobalPhaseGate
 from qiskit.providers import Provider
 from qiskit.providers.backend import BackendV2
-from qiskit.providers.models import BackendConfiguration
+from qiskit.providers.models.backendconfiguration import BackendConfiguration
 from qiskit.providers.options import Options
 from qiskit.qobj import QasmQobj, QasmQobjConfig, QasmQobjExperiment
 from qiskit.result import Result

qiskit/providers/fake_provider/fake_openpulse_2q.py

@@ -16,14 +16,14 @@ Fake backend supporting OpenPulse.
 import datetime
 import warnings
 
-from qiskit.providers.models import (
+from qiskit.providers.models.backendconfiguration import (
     GateConfig,
     PulseBackendConfiguration,
-    PulseDefaults,
-    Command,
     UchannelLO,
 )
+
 from qiskit.providers.models.backendproperties import Nduv, Gate, BackendProperties
+from qiskit.providers.models.pulsedefaults import PulseDefaults, Command
 from qiskit.qobj import PulseQobjInstruction
 
 from .fake_backend import FakeBackend

qiskit/providers/fake_provider/fake_openpulse_3q.py

@@ -15,13 +15,12 @@ Fake backend supporting OpenPulse.
 """
 import warnings
 
-from qiskit.providers.models import (
+from qiskit.providers.models.backendconfiguration import (
     GateConfig,
     PulseBackendConfiguration,
-    PulseDefaults,
-    Command,
     UchannelLO,
 )
+from qiskit.providers.models.pulsedefaults import PulseDefaults, Command
 from qiskit.qobj import PulseQobjInstruction
 
 from .fake_backend import FakeBackend

qiskit/providers/fake_provider/fake_pulse_backend.py

@@ -15,7 +15,8 @@ Fake backend abstract class for mock backends supporting OpenPulse.
 """
 
 from qiskit.exceptions import QiskitError
-from qiskit.providers.models import PulseBackendConfiguration, PulseDefaults
+from qiskit.providers.models.backendconfiguration import PulseBackendConfiguration
+from qiskit.providers.models.pulsedefaults import PulseDefaults
 
 from .fake_qasm_backend import FakeQasmBackend
 from .utils.json_decoder import decode_pulse_defaults

qiskit/providers/fake_provider/fake_qasm_backend.py

@@ -19,7 +19,8 @@ import os
 import warnings
 
 from qiskit.exceptions import QiskitError
-from qiskit.providers.models import BackendProperties, QasmBackendConfiguration
+from qiskit.providers.models.backendproperties import BackendProperties
+from qiskit.providers.models.backendconfiguration import QasmBackendConfiguration
 
 from .utils.json_decoder import (
     decode_backend_configuration,