qiskit 2.0.0rc2__cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 2.0.1__cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/VERSION.txt

@@ -1 +1 @@
-2.0.0rc2
+2.0.1

qiskit/__init__.py

@@ -53,11 +53,8 @@ import qiskit._numpy_compat
 # and not have to rely on attribute access.  No action needed for top-level extension packages.
 sys.modules["qiskit._accelerate.circuit"] = _accelerate.circuit
 sys.modules["qiskit._accelerate.circuit_library"] = _accelerate.circuit_library
-sys.modules["qiskit._accelerate.basis"] = _accelerate.basis
-sys.modules["qiskit._accelerate.basis.basis_translator"] = _accelerate.basis.basis_translator
+sys.modules["qiskit._accelerate.basis_translator"] = _accelerate.basis_translator
 sys.modules["qiskit._accelerate.converters"] = _accelerate.converters
-sys.modules["qiskit._accelerate.basis"] = _accelerate.basis
-sys.modules["qiskit._accelerate.basis.basis_translator"] = _accelerate.basis.basis_translator
 sys.modules["qiskit._accelerate.dense_layout"] = _accelerate.dense_layout
 sys.modules["qiskit._accelerate.equivalence"] = _accelerate.equivalence
 sys.modules["qiskit._accelerate.error_map"] = _accelerate.error_map

qiskit/circuit/__init__.py

@@ -272,7 +272,8 @@ circuit.  The top-level ones are:
     * :class:`ForLoopOp`, to loop over a fixed range of values
     * :class:`IfElseOp`, to conditionally enter one of two subcircuits
     * :class:`SwitchCaseOp`, to conditionally enter one of many subcircuits
-    * :class:`WhileLoopOp`, to repeat a subcircuit until a condition is falsified.
+    * :class:`WhileLoopOp`, to repeat a subcircuit until a condition is falsified
+    * :class:`BoxOp`, to group a series of instructions for later processing
 
 :ref:`Circuits can include classical expressions that are evaluated in real time
 <circuit-repr-real-time-classical>`, while the QPU is executing a single shot of the circuit.  These
@@ -303,9 +304,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.random_clifford_circuit`
 
 Finally, the circuit module has its own exception class, to indicate when things went wrong in
 circuit-specific manners:
@@ -558,6 +560,8 @@ Hardware can be instructed to apply a real-time idle period on a given qubit.  A
 
 .. autoclass:: Delay
     :show-inheritance:
+.. autoclass:: Duration
+
 
 The :class:`Barrier` instruction can span an arbitrary number of qubits and clbits, and is a no-op
 in hardware.  During transpilation and optimization, however, it blocks any optimizations from
@@ -707,9 +711,9 @@ classes associated to each name.
 .. autofunction:: get_control_flow_name_mapping
 
 These control-flow operations (:class:`IfElseOp`, :class:`WhileLoopOp`,
-:class:`SwitchCaseOp` and :class:`ForLoopOp`) all have specific state that defines the branching
-conditions and strategies, but contain all the different subcircuit blocks that might be entered in
-their :attr:`~ControlFlowOp.blocks` property.
+:class:`SwitchCaseOp`, :class:`ForLoopOp` and :class:`BoxOp`) all have specific state that defines
+the branching conditions and strategies, but contain all the different subcircuit blocks that
+might be entered in their :attr:`~ControlFlowOp.blocks` property.
 
 .. autosummary::
     :toctree: ../stubs/
@@ -718,6 +722,7 @@ their :attr:`~ControlFlowOp.blocks` property.
     WhileLoopOp
     SwitchCaseOp
     ForLoopOp
+    BoxOp
 
 The :class:`.SwitchCaseOp` also understands a special value:
 
@@ -1058,6 +1063,7 @@ Generating random circuits
 
 .. currentmodule:: qiskit.circuit.random
 .. autofunction:: random_circuit
+.. autofunction:: random_clifford_circuit
 .. currentmodule:: qiskit.circuit
 
 Apply Pauli twirling to a circuit

qiskit/circuit/classical/expr/constructors.py

@@ -683,16 +683,8 @@ Duration())
         left = _coerce_lossless(left, type)
         right = _coerce_lossless(right, type)
     elif left.type.kind is types.Duration and right.type.kind in {types.Uint, types.Float}:
-        if not right.const:
-            raise ValueError(
-                f"multiplying operands '{left}' and '{right}' would result in a non-const '{left.type}'"
-            )
         type = left.type
     elif right.type.kind is types.Duration and left.type.kind in {types.Uint, types.Float}:
-        if not left.const:
-            raise ValueError(
-                f"multiplying operands '{left}' and '{right}' would result in a non-const '{right.type}'"
-            )
         type = right.type
     else:
         raise TypeError(f"invalid types for '{Binary.Op.MUL}': '{left.type}' and '{right.type}'")
@@ -761,10 +753,6 @@ Duration())
             left = _coerce_lossless(left, type)
             right = _coerce_lossless(right, type)
     elif left.type.kind is types.Duration and right.type.kind in {types.Uint, types.Float}:
-        if not right.const:
-            raise ValueError(
-                f"division of '{left}' and '{right}' would result in a non-const '{left.type}'"
-            )
         type = left.type
     else:
         raise TypeError(f"invalid types for '{Binary.Op.DIV}': '{left.type}' and '{right.type}'")