qiskit 1.1.0__cp38-abi3-win32.whl → 1.1.0rc1__cp38-abi3-win32.whl

qiskit/converters/__init__.py

@@ -17,27 +17,12 @@ Circuit Converters (:mod:`qiskit.converters`)
 
 .. currentmodule:: qiskit.converters
 
-QuantumCircuit -> circuit components
-====================================
-
-.. autofunction:: circuit_to_instruction
-.. autofunction:: circuit_to_gate
-
-QuantumCircuit <-> DagCircuit 
-=============================
-
 .. autofunction:: circuit_to_dag
 .. autofunction:: dag_to_circuit
-
-QuantumCircuit <-> DagDependency 
-================================
-
+.. autofunction:: circuit_to_instruction
+.. autofunction:: circuit_to_gate
 .. autofunction:: dagdependency_to_circuit
 .. autofunction:: circuit_to_dagdependency
-
-DagCircuit <-> DagDependency 
-============================
-
 .. autofunction:: dag_to_dagdependency
 .. autofunction:: dagdependency_to_dag
 """

qiskit/passmanager/passmanager.py

@@ -21,7 +21,7 @@ from typing import Any
 
 import dill
 
-from qiskit.utils.parallel import parallel_map, should_run_in_parallel
+from qiskit.utils.parallel import parallel_map
 from .base_tasks import Task, PassManagerIR
 from .exceptions import PassManagerError
 from .flow_controllers import FlowControllerLinear
@@ -225,16 +225,16 @@ class BasePassManager(ABC):
             in_programs = [in_programs]
             is_list = False
 
-        # If we're not going to run in parallel, we want to avoid spending time `dill` serialising
-        # ourselves, since that can be quite expensive.
-        if len(in_programs) == 1 or not should_run_in_parallel(num_processes):
-            out = [
-                _run_workflow(program=program, pass_manager=self, callback=callback, **kwargs)
-                for program in in_programs
-            ]
-            if len(in_programs) == 1 and not is_list:
-                return out[0]
-            return out
+        if len(in_programs) == 1:
+            out_program = _run_workflow(
+                program=in_programs[0],
+                pass_manager=self,
+                callback=callback,
+                **kwargs,
+            )
+            if is_list:
+                return [out_program]
+            return out_program
 
         del callback
         del kwargs

qiskit/primitives/__init__.py

@@ -51,7 +51,7 @@ define a computation unit of work for the estimator to complete:
 * a collection parameter value sets to bind the circuit against, :math:`\theta_k`.
 
 Running an estimator returns a :class:`~qiskit.primitives.BasePrimitiveJob` object, where calling
-the method :meth:`~qiskit.primitives.BasePrimitiveJob.result` results in expectation value estimates
+the method :meth:`~qiskit.primitives.BasePrimitiveJob.result` results in expectation value estimates 
 and metadata for each pub:
 
 .. math::
@@ -95,7 +95,7 @@ Here is an example of how an estimator is used.
     #             [<psi2(theta2)|H2|psi2(theta2)>] ]
     job2 = estimator.run(
         [
-            (psi1, [H1, H3], [theta1, theta3]),
+            (psi1, [H1, H3], [theta1, theta3]), 
             (psi2, H2, theta2)
         ],
         precision=0.01
@@ -103,7 +103,7 @@ Here is an example of how an estimator is used.
     job_result = job2.result()
     print(f"The primitive-job finished with result {job_result}")
 
-
+    
 Overview of SamplerV2
 =====================
 
@@ -220,8 +220,8 @@ Here is an example of how the estimator is used.
     #             <psi2(theta2)|H2|psi2(theta2)>,
     #             <psi1(theta3)|H3|psi1(theta3)> ]
     job2 = estimator.run(
-        [psi1, psi2, psi1],
-        [H1, H2, H3],
+        [psi1, psi2, psi1], 
+        [H1, H2, H3], 
         [theta1, theta2, theta3]
     )
     job_result = job2.result()
@@ -417,10 +417,8 @@ Results V2
    DataBin
    PrimitiveResult
    PubResult
-   SamplerPubResult
    BasePrimitiveJob
    PrimitiveJob
-   Shaped
 
 Estimator V1
 ------------
@@ -466,16 +464,12 @@ from .containers import (
     DataBin,
     PrimitiveResult,
     PubResult,
-    SamplerPubResult,
     EstimatorPubLike,
     SamplerPubLike,
     BindingsArrayLike,
     ObservableLike,
     ObservablesArrayLike,
-    Shaped,
 )
-
-
 from .estimator import Estimator
 from .primitive_job import BasePrimitiveJob, PrimitiveJob
 from .sampler import Sampler

qiskit/primitives/containers/__init__.py

@@ -24,4 +24,3 @@ from .primitive_result import PrimitiveResult
 from .pub_result import PubResult
 from .sampler_pub import SamplerPubLike
 from .sampler_pub_result import SamplerPubResult
-from .shape import Shaped

qiskit/primitives/containers/bit_array.py

@@ -130,7 +130,6 @@ class BitArray(ShapedMixin):
         return f"BitArray({desc})"
 
     def __getitem__(self, indices):
-        """Slices the array along an existing axis of the array."""
         if isinstance(indices, tuple) and len(indices) >= self.ndim + 2:
             raise ValueError(
                 "BitArrays cannot be sliced along the bits axis, see slice_bits() instead."

qiskit/primitives/containers/shape.py

@@ -59,15 +59,15 @@ class ShapedMixin(Shaped):
         return f"{type(self).__name__}(<{self.shape}>)"
 
     @property
-    def shape(self) -> tuple[int, ...]:
+    def shape(self):
         return self._shape
 
     @property
-    def ndim(self) -> int:
+    def ndim(self):
         return len(self._shape)
 
     @property
-    def size(self) -> int:
+    def size(self):
         return int(np.prod(self._shape, dtype=int))
 
 

qiskit/providers/__init__.py

@@ -131,6 +131,7 @@ Exceptions
 .. autoexception:: JobTimeoutError
 .. autoexception:: BackendConfigurationError
 
+=====================
 Writing a New Backend
 =====================
 
@@ -163,7 +164,7 @@ For a simple example of a provider, see the
 `qiskit-aqt-provider <https://github.com/Qiskit-Partners/qiskit-aqt-provider>`__
 
 Provider
---------
+========
 
 A provider class serves a single purpose: to get backend objects that enable
 executing circuits on a device or simulator. The expectation is that any
@@ -194,7 +195,7 @@ authentication (if required) are present in the class and that the backends
 method matches the required interface. The rest is up to the specific provider on how to implement.
 
 Backend
--------
+=======
 
 The backend classes are the core to the provider. These classes are what
 provide the interface between Qiskit and the hardware or simulator that will
@@ -275,8 +276,8 @@ example would be something like::
             return MyJob(self. job_handle, job_json, circuit)
 
 
-Backend's Transpiler Interface
-------------------------------
+Transpiler Interface
+--------------------
 
 The key piece of the :class:`~qiskit.providers.Backend` object is how it describes itself to the
 compiler. This is handled with the :class:`~qiskit.transpiler.Target` class which defines
@@ -452,45 +453,8 @@ This way if these two compilation steps are **required** for running or providin
 efficient output on ``Mybackend`` the transpiler will be able to perform these
 custom steps without any manual user input.
 
-.. _providers-guide-real-time-variables:
-
-Real-time variables
-^^^^^^^^^^^^^^^^^^^
-
-The transpiler will automatically handle real-time typed classical variables (see
-:mod:`qiskit.circuit.classical`) and treat the :class:`.Store` instruction as a built-in
-"directive", similar to :class:`.Barrier`.  No special handling from backends is necessary to permit
-this.
-
-If your backend is *unable* to handle classical variables and storage, we recommend that you comment
-on this in your documentation, and insert a check into your :meth:`~.BackendV2.run` method (see
-:ref:`providers-guide-backend-run`) to eagerly reject circuits containing them.  You can examine
-:attr:`.QuantumCircuit.num_vars` for the presence of variables at the top level.  If you accept
-:ref:`control-flow operations <circuit-control-flow-repr>`, you might need to recursively search the
-internal :attr:`~.ControlFlowOp.blocks` of each for scope-local variables with
-:attr:`.QuantumCircuit.num_declared_vars`.
-
-For example, a function to check for the presence of any manual storage locations, or manual stores
-to memory::
-
-    from qiskit.circuit import Store, ControlFlowOp, QuantumCircuit
-
-    def has_realtime_logic(circuit: QuantumCircuit) -> bool:
-        if circuit.num_vars:
-            return True
-        for instruction in circuit.data:
-            if isinstance(instruction.operation, Store):
-                return True
-            elif isinstance(instruction.operation, ControlFlowOp):
-                for block in instruction.operation.blocks:
-                    if has_realtime_logic(block):
-                        return True
-        return False
-
-.. _providers-guide-backend-run:
-
-Backend.run Method
-------------------
+Run Method
+----------
 
 Of key importance is the :meth:`~qiskit.providers.BackendV2.run` method, which
 is used to actually submit circuits to a device or simulator. The run method
@@ -520,8 +484,8 @@ An example run method would be something like::
         job_handle = submit_to_backend(job_jsonb)
         return MyJob(self. job_handle, job_json, circuit)
 
-Backend Options
----------------
+Options
+-------
 
 There are often several options for a backend that control how a circuit is run.
 The typical example of this is something like the number of ``shots`` which is
@@ -551,7 +515,7 @@ for a full list of validation options.
 
 
 Job
----
+===
 
 The output from the :obj:`~qiskit.providers.BackendV2.run` method is a :class:`~qiskit.providers.JobV1`
 object. Each provider is expected to implement a custom job subclass that
@@ -648,7 +612,7 @@ and for a sync job::
             return JobStatus.DONE
 
 Primitives
-----------
+==========
 
 While not directly part of the provider interface, the :mod:`qiskit.primitives`
 module is tightly coupled with providers. Specifically the primitive
@@ -676,8 +640,12 @@ implementations. Also the built-in implementations: :class:`~.Sampler`,
 :class:`~.Estimator`, :class:`~.BackendSampler`, and :class:`~.BackendEstimator`
 can serve as references/models on how to implement these as well.
 
-Migrating from BackendV1 to BackendV2
-=====================================
+======================================
+Migrating between Backend API Versions
+======================================
+
+BackendV1 -> BackendV2
+======================
 
 The :obj:`~BackendV2` class re-defined user access for most properties of a
 backend to make them work with native Qiskit data structures and have flatter

qiskit/providers/basic_provider/__init__.py

@@ -27,15 +27,36 @@ via the `BasicProvider` provider, e.g.:
    backend = BasicProvider().get_backend('basic_simulator')
 
 
-Classes
-=======
+Simulators
+==========
 
 .. autosummary::
    :toctree: ../stubs/
 
    BasicSimulator
+
+Provider
+========
+
+.. autosummary::
+   :toctree: ../stubs/
+
    BasicProvider
+
+Job Class
+=========
+
+.. autosummary::
+   :toctree: ../stubs/
+
    BasicProviderJob
+
+Exceptions
+==========
+
+.. autosummary::
+   :toctree: ../stubs/
+
    BasicProviderError
 """
 

qiskit/providers/fake_provider/__init__.py

@@ -24,7 +24,7 @@ The fake provider module in Qiskit contains fake (simulated) backend classes
 useful for testing the transpiler and other backend-facing functionality.
 
 Example Usage
--------------
+=============
 
 Here is an example of using a simulated backend for transpilation and running.
 

qiskit/providers/models/__init__.py

@@ -19,8 +19,8 @@ Backend Objects (:mod:`qiskit.providers.models`)
 
 Qiskit schema-conformant objects used by the backends and providers.
 
-Classes
-=======
+Backend Objects
+===============
 
 .. autosummary::
    :toctree: ../stubs/

qiskit/qobj/converters/pulse_instruction.py

@@ -234,7 +234,7 @@ class InstructionToQobjConverter:
             "name": "setf",
             "t0": time_offset + instruction.start_time,
             "ch": instruction.channel.name,
-            "frequency": instruction.frequency / 10**9,
+            "frequency": instruction.frequency / 1e9,
         }
         return self._qobj_model(**command_dict)
 
@@ -257,7 +257,7 @@ class InstructionToQobjConverter:
             "name": "shiftf",
             "t0": time_offset + instruction.start_time,
             "ch": instruction.channel.name,
-            "frequency": instruction.frequency / 10**9,
+            "frequency": instruction.frequency / 1e9,
         }
         return self._qobj_model(**command_dict)
 
@@ -746,7 +746,7 @@ class QobjToInstructionConverter:
         .. note::
 
             We assume frequency value is expressed in string with "GHz".
-            Operand value is thus scaled by a factor of 10^9.
+            Operand value is thus scaled by a factor of 1e9.
 
         Args:
             instruction: SetFrequency qobj instruction
@@ -755,7 +755,7 @@ class QobjToInstructionConverter:
             Qiskit Pulse set frequency instructions
         """
         channel = self.get_channel(instruction.ch)
-        frequency = self.disassemble_value(instruction.frequency) * 10**9
+        frequency = self.disassemble_value(instruction.frequency) * 1e9
 
         yield instructions.SetFrequency(frequency, channel)
 
@@ -768,7 +768,7 @@ class QobjToInstructionConverter:
         .. note::
 
             We assume frequency value is expressed in string with "GHz".
-            Operand value is thus scaled by a factor of 10^9.
+            Operand value is thus scaled by a factor of 1e9.
 
         Args:
             instruction: ShiftFrequency qobj instruction
@@ -777,7 +777,7 @@ class QobjToInstructionConverter:
             Qiskit Pulse shift frequency schedule instructions
         """
         channel = self.get_channel(instruction.ch)
-        frequency = self.disassemble_value(instruction.frequency) * 10**9
+        frequency = self.disassemble_value(instruction.frequency) * 1e9
 
         yield instructions.ShiftFrequency(frequency, channel)