qiskit 1.4.1__cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl → 2.0.0__cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl

qiskit/VERSION.txt

@@ -1 +1 @@
-1.4.1
+2.0.0

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
@@ -81,7 +78,6 @@ sys.modules["qiskit._accelerate.sampled_exp_val"] = _accelerate.sampled_exp_val
 sys.modules["qiskit._accelerate.sparse_observable"] = _accelerate.sparse_observable
 sys.modules["qiskit._accelerate.sparse_pauli_op"] = _accelerate.sparse_pauli_op
 sys.modules["qiskit._accelerate.star_prerouting"] = _accelerate.star_prerouting
-sys.modules["qiskit._accelerate.stochastic_swap"] = _accelerate.stochastic_swap
 sys.modules["qiskit._accelerate.elide_permutations"] = _accelerate.elide_permutations
 sys.modules["qiskit._accelerate.target"] = _accelerate.target
 sys.modules["qiskit._accelerate.two_qubit_decompose"] = _accelerate.two_qubit_decompose
@@ -128,10 +124,11 @@ import qiskit.circuit.reset
 
 _config = _user_config.get_config()
 
-from qiskit.compiler import transpile, assemble, schedule, sequence
+from qiskit.compiler import transpile
 from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
 from .version import __version__
 
+
 __all__ = [
     "AncillaRegister",
     "ClassicalRegister",
@@ -139,9 +136,6 @@ __all__ = [
     "QiskitError",
     "QuantumCircuit",
     "QuantumRegister",
-    "assemble",
-    "schedule",
-    "sequence",
     "transpile",
     "generate_preset_pass_manager",
 ]

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,10 +560,16 @@ 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
-"crossing" the barrier; that is, in::
+"crossing" the barrier; that is, in:
+
+.. plot::
+    :include-source:
+    :nofigs:
 
     from qiskit.circuit import QuantumCircuit
 
@@ -697,10 +705,15 @@ attributes of each of the control-flow operations.
 
     Set of the instruction names of Qiskit's known control-flow operations.
 
+The :func:`.get_control_flow_name_mapping` function allows to access the control-flow operation
+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/
@@ -709,6 +722,7 @@ their :attr:`~ControlFlowOp.blocks` property.
     WhileLoopOp
     SwitchCaseOp
     ForLoopOp
+    BoxOp
 
 The :class:`.SwitchCaseOp` also understands a special value:
 
@@ -1049,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
@@ -1273,11 +1288,21 @@ In both these cases, the matrix form of :class:`.CCXGate` in ``ctrl_state = 1``
         \end{pmatrix}
 """
 
+from qiskit._accelerate.circuit import (  # pylint: disable=unused-import
+    Bit,
+    Qubit,
+    AncillaQubit,
+    Clbit,
+    QuantumRegister,
+    AncillaRegister,
+    ClassicalRegister,
+    Register,
+    Duration,
+)
+
 from .exceptions import CircuitError
 from . import _utils
 from .quantumcircuit import QuantumCircuit
-from .classicalregister import ClassicalRegister, Clbit
-from .quantumregister import QuantumRegister, Qubit, AncillaRegister, AncillaQubit
 from .gate import Gate
 
 # pylint: disable=cyclic-import
@@ -1296,14 +1321,13 @@ from .parametervector import ParameterVector, ParameterVectorElement
 from .parameterexpression import ParameterExpression
 from .quantumcircuitdata import CircuitInstruction
 from .equivalence import EquivalenceLibrary
-from .bit import Bit
-from .register import Register
 from . import library
 from .equivalence_library import StandardEquivalenceLibrary, SessionEquivalenceLibrary
 from .commutation_checker import CommutationChecker
 
 from .controlflow import (
     ControlFlowOp,
+    BoxOp,
     WhileLoopOp,
     ForLoopOp,
     IfElseOp,
@@ -1312,6 +1336,7 @@ from .controlflow import (
     BreakLoopOp,
     ContinueLoopOp,
     CONTROL_FLOW_OP_NAMES,
+    get_control_flow_name_mapping,
 )
 
 from .annotated_operation import AnnotatedOperation, InverseModifier, ControlModifier, PowerModifier

qiskit/circuit/{add_control.py → _add_control.py}

@@ -109,7 +109,7 @@ def control(
 
     global_phase = 0
 
-    basis = ["p", "u", "x", "z", "rx", "ry", "rz", "cx"]
+    basis = ["p", "u", "x", "z", "y", "h", "sx", "sxdg", "rx", "ry", "rz", "cx"]
 
     if operation.name in basis:
         apply_basic_controlled_gate(controlled_circ, operation, q_control, q_target[0])
@@ -187,7 +187,7 @@ def apply_basic_controlled_gate(circuit, gate, controls, target):
 
     This implements multi-control operations for the following basis gates:
 
-        ["p", "u", "x", "z", "rx", "ry", "rz", "cx"]
+        ["p", "u", "x", "z", "y", "h", "sx", "sxdg", "rx", "ry", "rz", "cx"]
 
     """
     num_ctrl_qubits = len(controls)
@@ -239,31 +239,51 @@ def apply_basic_controlled_gate(circuit, gate, controls, target):
                 circuit.cu(theta, phi, lamb, 0, controls[0], target)
         else:
             if phi == -pi / 2 and lamb == pi / 2:
-                circuit.mcrx(theta, controls, target, use_basis_gates=True)
+                circuit.mcrx(theta, controls, target, use_basis_gates=False)
             elif phi == 0 and lamb == 0:
                 circuit.mcry(
                     theta,
                     controls,
                     target,
-                    use_basis_gates=True,
+                    use_basis_gates=False,
                 )
             elif theta == 0 and phi == 0:
                 circuit.mcp(lamb, controls, target)
             else:
-                circuit.mcp(lamb, controls, target)
-                circuit.mcry(
-                    theta,
-                    controls,
-                    target,
-                    use_basis_gates=True,
-                )
-                circuit.mcp(phi, controls, target)
+                circuit.mcrz(lamb, controls, target, use_basis_gates=False)
+                circuit.mcry(theta, controls, target, use_basis_gates=False)
+                circuit.mcrz(phi, controls, target, use_basis_gates=False)
+                circuit.mcp((phi + lamb) / 2, controls[1:], controls[0])
 
     elif gate.name == "z":
         circuit.h(target)
         circuit.mcx(controls, target)
         circuit.h(target)
 
+    elif gate.name == "y":
+        circuit.sdg(target)
+        circuit.mcx(controls, target)
+        circuit.s(target)
+
+    elif gate.name == "h":
+        circuit.s(target)
+        circuit.h(target)
+        circuit.t(target)
+        circuit.mcx(controls, target)
+        circuit.tdg(target)
+        circuit.h(target)
+        circuit.sdg(target)
+
+    elif gate.name == "sx":
+        circuit.h(target)
+        circuit.mcp(pi / 2, controls, target)
+        circuit.h(target)
+
+    elif gate.name == "sxdg":
+        circuit.h(target)
+        circuit.mcp(3 * pi / 2, controls, target)
+        circuit.h(target)
+
     else:
         raise CircuitError(f"Gate {gate} not in supported basis.")
 

qiskit/circuit/_classical_resource_map.py

@@ -16,9 +16,8 @@ from __future__ import annotations
 
 import typing
 
-from .bit import Bit
+from . import Bit, Clbit, ClassicalRegister  # pylint: disable=cyclic-import
 from .classical import expr
-from .classicalregister import ClassicalRegister, Clbit
 
 
 class VariableMapper(expr.ExprVisitor[expr.Expr]):
@@ -43,7 +42,7 @@ class VariableMapper(expr.ExprVisitor[expr.Expr]):
         self,
         target_cregs: typing.Iterable[ClassicalRegister],
         bit_map: typing.Mapping[Bit, Bit],
-        var_map: typing.Mapping[expr.Var, expr.Var] | None = None,
+        var_map: typing.Mapping[expr.Var | expr.Stretch, expr.Var | expr.Stretch] | None = None,
         *,
         add_register: typing.Callable[[ClassicalRegister], None] | None = None,
     ):
@@ -132,6 +131,9 @@ class VariableMapper(expr.ExprVisitor[expr.Expr]):
             return expr.Var(self._map_register(node.var), node.type)
         return self.var_map.get(node, node)
 
+    def visit_stretch(self, node, /):
+        return self.var_map.get(node, node)
+
     def visit_value(self, node, /):
         return expr.Value(node.value, node.type)
 

qiskit/circuit/barrier.py

@@ -18,9 +18,8 @@ with the :meth:`~qiskit.circuit.QuantumCircuit.barrier` method.
 
 from __future__ import annotations
 
-from qiskit.exceptions import QiskitError
-from qiskit.utils import deprecate_func
-from .instruction import Instruction
+from qiskit.circuit.instruction import Instruction
+from qiskit._accelerate.circuit import StandardInstructionType
 
 
 class Barrier(Instruction):
@@ -31,6 +30,7 @@ class Barrier(Instruction):
     """
 
     _directive = True
+    _standard_instruction_type = StandardInstructionType.Barrier
 
     def __init__(self, num_qubits: int, label: str | None = None):
         """
@@ -44,7 +44,3 @@ class Barrier(Instruction):
     def inverse(self, annotated: bool = False):
         """Special case. Return self."""
         return Barrier(self.num_qubits)
-
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
-    def c_if(self, classical, val):
-        raise QiskitError("Barriers are compiler directives and cannot be conditional.")

qiskit/circuit/classical/expr/__init__.py

@@ -39,6 +39,10 @@ The expression system is based on tree representation.  All nodes in the tree ar
 
 These objects are mutable and should not be reused in a different location without a copy.
 
+All :class`Expr` instances define a boolean :attr:`~Expr.const` attribute, which indicates
+whether the expression can be evaluated at compile time. Most expression classes infer this
+during construction based on the const-ness of their operands.
+
 The base for dynamic variables is the :class:`Var`, which can be either an arbitrarily typed
 real-time variable, or a wrapper around a :class:`.Clbit` or :class:`.ClassicalRegister`.
 
@@ -46,10 +50,15 @@ real-time variable, or a wrapper around a :class:`.Clbit` or :class:`.ClassicalR
     :members: var, name, new
 
 Similarly, literals used in expressions (such as integers) should be lifted to :class:`Value` nodes
-with associated types.
+with associated types. A :class:`Value` is always considered a constant expression.
 
 .. autoclass:: Value
 
+Stretch variables for use in duration expressions are represented by the :class:`Stretch` node.
+
+.. autoclass:: Stretch
+    :members: var, name, new
+
 The operations traditionally associated with pre-, post- or infix operators in programming are
 represented by the :class:`Unary` and :class:`Binary` nodes as appropriate.  These each take an
 operation type code, which are exposed as enumerations inside each class as :class:`Unary.Op`
@@ -130,6 +139,10 @@ Similarly, the binary operations and relations have helper functions defined.
 .. autofunction:: greater_equal
 .. autofunction:: shift_left
 .. autofunction:: shift_right
+.. autofunction:: add
+.. autofunction:: sub
+.. autofunction:: mul
+.. autofunction:: div
 
 You can index into unsigned integers and bit-likes using another unsigned integer of any width.
 This includes in storing operations, if the target of the index is writeable.
@@ -166,6 +179,11 @@ not the general structure, the iterator method :func:`iter_vars` is provided.
 
 .. autofunction:: iter_vars
 
+To iterator over all variables including stretch variables, the iterator method
+:func:`iter_identifiers` is provided.
+
+.. autofunction:: iter_identifiers
+
 Two expressions can be compared for direct structural equality by using the built-in Python ``==``
 operator.  In general, though, one might want to compare two expressions slightly more semantically,
 allowing that the :class:`Var` nodes inside them are bound to different memory-location descriptions
@@ -188,8 +206,10 @@ __all__ = [
     "Unary",
     "Binary",
     "Index",
+    "Stretch",
     "ExprVisitor",
     "iter_vars",
+    "iter_identifiers",
     "structurally_equivalent",
     "is_lvalue",
     "lift",
@@ -210,11 +230,15 @@ __all__ = [
     "greater",
     "greater_equal",
     "index",
+    "add",
+    "sub",
+    "mul",
+    "div",
     "lift_legacy_condition",
 ]
 
-from .expr import Expr, Var, Value, Cast, Unary, Binary, Index
-from .visitors import ExprVisitor, iter_vars, structurally_equivalent, is_lvalue
+from .expr import Expr, Var, Value, Cast, Unary, Binary, Index, Stretch
+from .visitors import ExprVisitor, iter_vars, iter_identifiers, structurally_equivalent, is_lvalue
 from .constructors import (
     lift,
     cast,
@@ -234,5 +258,9 @@ from .constructors import (
     shift_left,
     shift_right,
     index,
+    add,
+    sub,
+    mul,
+    div,
     lift_legacy_condition,
 )