qiskit 1.1.1__cp38-abi3-win32.whl → 1.2.0__cp38-abi3-win32.whl

qiskit/VERSION.txt

@@ -1 +1 @@
-1.1.1
+1.2.0

qiskit/__init__.py

@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-# pylint: disable=wrong-import-position
+# pylint: disable=wrong-import-position,wrong-import-order
 
 """Main Qiskit public functionality."""
 
@@ -52,36 +52,38 @@ if sys.version_info < (3, 9):
     )
 
 
-import qiskit._accelerate
+from . import _accelerate
 import qiskit._numpy_compat
 
 # Globally define compiled submodules. The normal import mechanism will not find compiled submodules
 # in _accelerate because it relies on file paths, but PyO3 generates only one shared library file.
 # We manually define them on import so people can directly import qiskit._accelerate.* submodules
 # and not have to rely on attribute access.  No action needed for top-level extension packages.
-sys.modules["qiskit._accelerate.circuit"] = qiskit._accelerate.circuit
-sys.modules["qiskit._accelerate.convert_2q_block_matrix"] = (
-    qiskit._accelerate.convert_2q_block_matrix
-)
-sys.modules["qiskit._accelerate.dense_layout"] = qiskit._accelerate.dense_layout
-sys.modules["qiskit._accelerate.error_map"] = qiskit._accelerate.error_map
-sys.modules["qiskit._accelerate.isometry"] = qiskit._accelerate.isometry
-sys.modules["qiskit._accelerate.uc_gate"] = qiskit._accelerate.uc_gate
+sys.modules["qiskit._accelerate.circuit"] = _accelerate.circuit
+sys.modules["qiskit._accelerate.convert_2q_block_matrix"] = _accelerate.convert_2q_block_matrix
+sys.modules["qiskit._accelerate.dense_layout"] = _accelerate.dense_layout
+sys.modules["qiskit._accelerate.error_map"] = _accelerate.error_map
+sys.modules["qiskit._accelerate.isometry"] = _accelerate.isometry
+sys.modules["qiskit._accelerate.uc_gate"] = _accelerate.uc_gate
 sys.modules["qiskit._accelerate.euler_one_qubit_decomposer"] = (
-    qiskit._accelerate.euler_one_qubit_decomposer
+    _accelerate.euler_one_qubit_decomposer
 )
-sys.modules["qiskit._accelerate.nlayout"] = qiskit._accelerate.nlayout
-sys.modules["qiskit._accelerate.optimize_1q_gates"] = qiskit._accelerate.optimize_1q_gates
-sys.modules["qiskit._accelerate.pauli_expval"] = qiskit._accelerate.pauli_expval
-sys.modules["qiskit._accelerate.qasm2"] = qiskit._accelerate.qasm2
-sys.modules["qiskit._accelerate.qasm3"] = qiskit._accelerate.qasm3
-sys.modules["qiskit._accelerate.results"] = qiskit._accelerate.results
-sys.modules["qiskit._accelerate.sabre"] = qiskit._accelerate.sabre
-sys.modules["qiskit._accelerate.sampled_exp_val"] = qiskit._accelerate.sampled_exp_val
-sys.modules["qiskit._accelerate.sparse_pauli_op"] = qiskit._accelerate.sparse_pauli_op
-sys.modules["qiskit._accelerate.stochastic_swap"] = qiskit._accelerate.stochastic_swap
-sys.modules["qiskit._accelerate.two_qubit_decompose"] = qiskit._accelerate.two_qubit_decompose
-sys.modules["qiskit._accelerate.vf2_layout"] = qiskit._accelerate.vf2_layout
+sys.modules["qiskit._accelerate.nlayout"] = _accelerate.nlayout
+sys.modules["qiskit._accelerate.optimize_1q_gates"] = _accelerate.optimize_1q_gates
+sys.modules["qiskit._accelerate.pauli_expval"] = _accelerate.pauli_expval
+sys.modules["qiskit._accelerate.qasm2"] = _accelerate.qasm2
+sys.modules["qiskit._accelerate.qasm3"] = _accelerate.qasm3
+sys.modules["qiskit._accelerate.results"] = _accelerate.results
+sys.modules["qiskit._accelerate.sabre"] = _accelerate.sabre
+sys.modules["qiskit._accelerate.sampled_exp_val"] = _accelerate.sampled_exp_val
+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.two_qubit_decompose"] = _accelerate.two_qubit_decompose
+sys.modules["qiskit._accelerate.vf2_layout"] = _accelerate.vf2_layout
+sys.modules["qiskit._accelerate.synthesis.permutation"] = _accelerate.synthesis.permutation
+sys.modules["qiskit._accelerate.synthesis.linear"] = _accelerate.synthesis.linear
+sys.modules["qiskit._accelerate.synthesis.clifford"] = _accelerate.synthesis.clifford
 
 from qiskit.exceptions import QiskitError, MissingOptionalLibraryError
 
@@ -100,7 +102,7 @@ import qiskit.circuit.reset
 _config = _user_config.get_config()
 
 from qiskit.compiler import transpile, assemble, schedule, sequence
-
+from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
 from .version import __version__
 
 __all__ = [
@@ -114,4 +116,5 @@ __all__ = [
     "schedule",
     "sequence",
     "transpile",
+    "generate_preset_pass_manager",
 ]

qiskit/_numpy_compat.py

@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Compatiblity helpers for the Numpy 1.x to 2.0 transition."""
+"""Compatibility helpers for the Numpy 1.x to 2.0 transition."""
 
 import re
 import typing

qiskit/assembler/assemble_circuits.py

@@ -12,6 +12,7 @@
 
 """Assemble function for converting a list of circuits into a qobj."""
 import copy
+import warnings
 from collections import defaultdict
 from typing import Dict, List, Optional, Tuple
 
@@ -35,6 +36,7 @@ from qiskit.qobj import (
     QobjHeader,
 )
 from qiskit.utils.parallel import parallel_map
+from qiskit.utils import deprecate_func
 
 
 PulseLibrary = Dict[str, List[complex]]
@@ -87,20 +89,26 @@ def _assemble_circuit(
     metadata = circuit.metadata
     if metadata is None:
         metadata = {}
-    header = QobjExperimentHeader(
-        qubit_labels=qubit_labels,
-        n_qubits=num_qubits,
-        qreg_sizes=qreg_sizes,
-        clbit_labels=clbit_labels,
-        memory_slots=memory_slots,
-        creg_sizes=creg_sizes,
-        name=circuit.name,
-        global_phase=float(circuit.global_phase),
-        metadata=metadata,
-    )
+    with warnings.catch_warnings():
+        # The class QobjExperimentHeader is deprecated
+        warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+        header = QobjExperimentHeader(
+            qubit_labels=qubit_labels,
+            n_qubits=num_qubits,
+            qreg_sizes=qreg_sizes,
+            clbit_labels=clbit_labels,
+            memory_slots=memory_slots,
+            creg_sizes=creg_sizes,
+            name=circuit.name,
+            global_phase=float(circuit.global_phase),
+            metadata=metadata,
+        )
 
     # TODO: why do we need n_qubits and memory_slots in both the header and the config
-    config = QasmQobjExperimentConfig(n_qubits=num_qubits, memory_slots=memory_slots)
+    with warnings.catch_warnings():
+        # The class QasmQobjExperimentConfig is deprecated
+        warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+        config = QasmQobjExperimentConfig(n_qubits=num_qubits, memory_slots=memory_slots)
     calibrations, pulse_library = _assemble_pulse_gates(circuit, run_config)
     if calibrations:
         config.calibrations = calibrations
@@ -118,7 +126,7 @@ def _assemble_circuit(
 
     instructions = []
     for op_context in circuit.data:
-        instruction = op_context.operation.assemble()
+        instruction = op_context.operation._assemble()
 
         # Add register attributes to the instruction
         qargs = op_context.qubits
@@ -151,13 +159,16 @@ def _assemble_circuit(
                         ]
 
             conditional_reg_idx = memory_slots + max_conditional_idx
-            conversion_bfunc = QasmQobjInstruction(
-                name="bfunc",
-                mask="0x%X" % mask,
-                relation="==",
-                val="0x%X" % val,
-                register=conditional_reg_idx,
-            )
+            with warnings.catch_warnings():
+                # The class QasmQobjInstruction is deprecated
+                warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+                conversion_bfunc = QasmQobjInstruction(
+                    name="bfunc",
+                    mask="0x%X" % mask,  # pylint: disable=consider-using-f-string
+                    relation="==",
+                    val="0x%X" % val,  # pylint: disable=consider-using-f-string
+                    register=conditional_reg_idx,
+                )
             instructions.append(conversion_bfunc)
             instruction.conditional = conditional_reg_idx
             max_conditional_idx += 1
@@ -166,10 +177,13 @@ def _assemble_circuit(
             del instruction._condition
 
         instructions.append(instruction)
-    return (
-        QasmQobjExperiment(instructions=instructions, header=header, config=config),
-        pulse_library,
-    )
+    with warnings.catch_warnings():
+        # The class QasmQobjExperiment is deprecated
+        warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+        return (
+            QasmQobjExperiment(instructions=instructions, header=header, config=config),
+            pulse_library,
+        )
 
 
 def _assemble_pulse_gates(
@@ -299,42 +313,14 @@ def _configure_experiment_los(
     return experiments
 
 
-def assemble_circuits(
+def _assemble_circuits(
     circuits: List[QuantumCircuit], run_config: RunConfig, qobj_id: int, qobj_header: QobjHeader
 ) -> QasmQobj:
-    """Assembles a list of circuits into a qobj that can be run on the backend.
-
-    Args:
-        circuits: circuit(s) to assemble
-        run_config: configuration of the runtime environment
-        qobj_id: identifier for the generated qobj
-        qobj_header: header to pass to the results
-
-    Returns:
-        The qobj to be run on the backends
-
-    Examples:
-
-        .. code-block:: python
-
-            from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
-            from qiskit.assembler import assemble_circuits
-            from qiskit.assembler.run_config import RunConfig
-            # Build a circuit to convert into a Qobj
-            q = QuantumRegister(2)
-            c = ClassicalRegister(2)
-            qc = QuantumCircuit(q, c)
-            qc.h(q[0])
-            qc.cx(q[0], q[1])
-            qc.measure(q, c)
-            # Assemble a Qobj from the input circuit
-            qobj = assemble_circuits(circuits=[qc],
-                                     qobj_id="custom-id",
-                                     qobj_header=[],
-                                     run_config=RunConfig(shots=2000, memory=True, init_qubits=True))
-    """
-    # assemble the circuit experiments
-    experiments_and_pulse_libs = parallel_map(_assemble_circuit, circuits, [run_config])
+    with warnings.catch_warnings():
+        # Still constructs Qobj, that is deprecated. The message is hard to trace to a module,
+        # because concurrency is hard.
+        warnings.filterwarnings("ignore", category=DeprecationWarning)
+        experiments_and_pulse_libs = parallel_map(_assemble_circuit, circuits, [run_config])
     experiments = []
     pulse_library = {}
     for exp, lib in experiments_and_pulse_libs:
@@ -346,10 +332,16 @@ def assemble_circuits(
     experiments, calibrations = _extract_common_calibrations(experiments)
 
     # configure LO freqs per circuit
-    lo_converter = converters.LoConfigConverter(QasmQobjExperimentConfig, **run_config.to_dict())
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+        lo_converter = converters.LoConfigConverter(
+            QasmQobjExperimentConfig, **run_config.to_dict()
+        )
     experiments = _configure_experiment_los(experiments, lo_converter, run_config)
 
-    qobj_config = QasmQobjConfig()
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+        qobj_config = QasmQobjConfig()
     if run_config:
         qobj_config_dict = run_config.to_dict()
 
@@ -379,7 +371,10 @@ def assemble_circuits(
             if m_los:
                 qobj_config_dict["meas_lo_freq"] = [freq / 1e9 for freq in m_los]
 
-        qobj_config = QasmQobjConfig(**qobj_config_dict)
+        with warnings.catch_warnings():
+            # The class QasmQobjConfig is deprecated
+            warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+            qobj_config = QasmQobjConfig(**qobj_config_dict)
 
     qubit_sizes = []
     memory_slot_sizes = []
@@ -402,7 +397,55 @@ def assemble_circuits(
 
     if calibrations and calibrations.gates:
         qobj_config.calibrations = calibrations
+    with warnings.catch_warnings():
+        # The class QasmQobj is deprecated
+        warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+        return QasmQobj(
+            qobj_id=qobj_id, config=qobj_config, experiments=experiments, header=qobj_header
+        )
 
-    return QasmQobj(
-        qobj_id=qobj_id, config=qobj_config, experiments=experiments, header=qobj_header
-    )
+
+@deprecate_func(
+    since="1.2",
+    removal_timeline="in the 2.0 release",
+    additional_msg="The `Qobj` class and related functionality are part of the deprecated `BackendV1` "
+    "workflow,  and no longer necessary for `BackendV2`. If a user workflow requires "
+    "`Qobj` it likely relies on deprecated functionality and should be updated to "
+    "use `BackendV2`.",
+)
+def assemble_circuits(
+    circuits: List[QuantumCircuit], run_config: RunConfig, qobj_id: int, qobj_header: QobjHeader
+) -> QasmQobj:
+    """Assembles a list of circuits into a qobj that can be run on the backend.
+
+    Args:
+        circuits: circuit(s) to assemble
+        run_config: configuration of the runtime environment
+        qobj_id: identifier for the generated qobj
+        qobj_header: header to pass to the results
+
+    Returns:
+        The qobj to be run on the backends
+
+    Examples:
+
+        .. code-block:: python
+
+            from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
+            from qiskit.assembler import assemble_circuits
+            from qiskit.assembler.run_config import RunConfig
+            # Build a circuit to convert into a Qobj
+            q = QuantumRegister(2)
+            c = ClassicalRegister(2)
+            qc = QuantumCircuit(q, c)
+            qc.h(q[0])
+            qc.cx(q[0], q[1])
+            qc.measure(q, c)
+            # Assemble a Qobj from the input circuit
+            qobj = assemble_circuits(circuits=[qc],
+                                     qobj_id="custom-id",
+                                     qobj_header=[],
+                                     run_config=RunConfig(shots=2000, memory=True, init_qubits=True))
+    """
+    # assemble the circuit experiments
+    return _assemble_circuits(circuits, run_config, qobj_id, qobj_header)

qiskit/assembler/assemble_schedules.py

@@ -152,7 +152,7 @@ def _assemble_experiments(
         # TODO: add other experimental header items (see circuit assembler)
         qobj_experiment_header = qobj.QobjExperimentHeader(
             memory_slots=max_memory_slot + 1,  # Memory slots are 0 indexed
-            name=sched.name or "Experiment-%d" % idx,
+            name=sched.name or f"Experiment-{idx}",
             metadata=metadata,
         )
 
@@ -306,18 +306,11 @@ def _validate_meas_map(
                 common_next = next_inst_qubits.intersection(meas_set)
                 if common_instr_qubits and common_next:
                     raise QiskitError(
-                        "Qubits {} and {} are in the same measurement grouping: {}. "
+                        f"Qubits {common_instr_qubits} and {common_next} are in the same measurement "
+                        f"grouping: {meas_map}. "
                         "They must either be acquired at the same time, or disjointly"
-                        ". Instead, they were acquired at times: {}-{} and "
-                        "{}-{}".format(
-                            common_instr_qubits,
-                            common_next,
-                            meas_map,
-                            inst[0][0],
-                            inst_end_time,
-                            next_inst_time,
-                            next_inst_time + next_inst[0][1],
-                        )
+                        f". Instead, they were acquired at times: {inst[0][0]}-{inst_end_time} and "
+                        f"{next_inst_time}-{next_inst_time + next_inst[0][1]}"
                     )
 
 

qiskit/assembler/disassemble.py

@@ -23,6 +23,7 @@ from qiskit.circuit.quantumregister import QuantumRegister
 
 from qiskit.qobj import PulseQobjInstruction
 from qiskit.qobj.converters import QobjToInstructionConverter
+from qiskit.utils import deprecate_func
 
 # A ``CircuitModule`` is a representation of a circuit execution on the backend.
 # It is currently a list of quantum circuits to execute, a run Qobj dictionary
@@ -37,6 +38,14 @@ CircuitModule = NewType(
 PulseModule = NewType("PulseModule", Tuple[List[pulse.Schedule], Dict[str, Any], Dict[str, Any]])
 
 
+@deprecate_func(
+    since="1.2",
+    removal_timeline="in the 2.0 release",
+    additional_msg="The `Qobj` class and related functionality are part of the deprecated "
+    "`BackendV1` workflow,  and no longer necessary for `BackendV2`. If a user "
+    "workflow requires `Qobj` it likely relies on deprecated functionality and "
+    "should be updated to use `BackendV2`.",
+)
 def disassemble(qobj) -> Union[CircuitModule, PulseModule]:
     """Disassemble a qobj and return the circuits or pulse schedules, run_config, and user header.
 
@@ -109,7 +118,7 @@ def _qobj_to_circuit_cals(qobj, pulse_lib):
         config = (tuple(gate["qubits"]), tuple(gate["params"]))
         cal = {
             config: pulse.Schedule(
-                name="{} {} {}".format(gate["name"], str(gate["params"]), str(gate["qubits"]))
+                name=f"{gate['name']} {str(gate['params'])} {str(gate['qubits'])}"
             )
         }
         for instruction in gate["instructions"]:

qiskit/circuit/__init__.py

@@ -270,7 +270,7 @@ circuit.  The top-level ones are:
     * :class:`ContinueLoopOp`, to move immediately to the next iteration of the containing loop
     * :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 subcicuits
+    * :class:`SwitchCaseOp`, to conditionally enter one of many subcircuits
     * :class:`WhileLoopOp`, to repeat a subcircuit until a condition is falsified.
 
 :ref:`Circuits can include classical expressions that are evaluated in real time
@@ -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:
@@ -1004,6 +1005,7 @@ Generating random circuits
 
 .. currentmodule:: qiskit.circuit.random
 .. autofunction:: random_circuit
+.. autofunction:: random_clifford_circuit
 .. currentmodule:: qiskit.circuit
 
 
@@ -1250,3 +1252,4 @@ from .controlflow import (
 )
 
 from .annotated_operation import AnnotatedOperation, InverseModifier, ControlModifier, PowerModifier
+from .random import random_circuit, random_clifford_circuit

qiskit/circuit/_classical_resource_map.py

@@ -31,7 +31,7 @@ class VariableMapper(expr.ExprVisitor[expr.Expr]):
     call its :meth:`map_condition`, :meth:`map_target` or :meth:`map_expr` methods as appropriate,
     which will return the new object that should be used.
 
-    If an ``add_register`` callable is given to the initialiser, the mapper will use it to attempt
+    If an ``add_register`` callable is given to the initializer, the mapper will use it to attempt
     to add new aliasing registers to the outer circuit object, if there is not already a suitable
     register for the mapping available in the circuit.  If this parameter is not given, a
     ``ValueError`` will be raised instead.  The given ``add_register`` callable may choose to raise
@@ -73,12 +73,12 @@ class VariableMapper(expr.ExprVisitor[expr.Expr]):
 
     def map_condition(self, condition, /, *, allow_reorder=False):
         """Map the given ``condition`` so that it only references variables in the destination
-        circuit (as given to this class on initialisation).
+        circuit (as given to this class on initialization).
 
         If ``allow_reorder`` is ``True``, then when a legacy condition (the two-tuple form) is made
         on a register that has a counterpart in the destination with all the same (mapped) bits but
         in a different order, then that register will be used and the value suitably modified to
-        make the equality condition work.  This is maintaining legacy (tested) behaviour of
+        make the equality condition work.  This is maintaining legacy (tested) behavior of
         :meth:`.DAGCircuit.compose`; nowhere else does this, and in general this would require *far*
         more complex classical rewriting than Terra needs to worry about in the full expression era.
         """
@@ -91,7 +91,7 @@ class VariableMapper(expr.ExprVisitor[expr.Expr]):
             return (self.bit_map[target], value)
         if not allow_reorder:
             return (self._map_register(target), value)
-        # This is maintaining the legacy behaviour of `DAGCircuit.compose`.  We don't attempt to
+        # This is maintaining the legacy behavior of `DAGCircuit.compose`.  We don't attempt to
         # speed-up this lookup with a cache, since that would just make the more standard cases more
         # annoying to deal with.
         mapped_bits_order = [self.bit_map[bit] for bit in target]
@@ -114,7 +114,7 @@ class VariableMapper(expr.ExprVisitor[expr.Expr]):
 
     def map_target(self, target, /):
         """Map the real-time variables in a ``target`` of a :class:`.SwitchCaseOp` to the new
-        circuit, as defined in the ``circuit`` argument of the initialiser of this class."""
+        circuit, as defined in the ``circuit`` argument of the initializer of this class."""
         if isinstance(target, Clbit):
             return self.bit_map[target]
         if isinstance(target, ClassicalRegister):

qiskit/circuit/_utils.py

@@ -19,19 +19,6 @@ import numpy
 from qiskit import _numpy_compat
 from qiskit.exceptions import QiskitError
 from qiskit.circuit.exceptions import CircuitError
-from .parametervector import ParameterVectorElement
-
-
-def sort_parameters(parameters):
-    """Sort an iterable of :class:`.Parameter` instances into a canonical order, respecting the
-    ordering relationships between elements of :class:`.ParameterVector`\\ s."""
-
-    def key(parameter):
-        if isinstance(parameter, ParameterVectorElement):
-            return (parameter.vector.name, parameter.index)
-        return (parameter.name,)
-
-    return sorted(parameters, key=key)
 
 
 def _compute_control_matrix(base_mat, num_ctrl_qubits, ctrl_state=None):

qiskit/circuit/add_control.py

@@ -73,7 +73,7 @@ def control(
 ) -> ControlledGate:
     """Return controlled version of gate using controlled rotations. This function
     first checks the name of the operation to see if it knows of a method from which
-    to generate a controlled version. Currently these are `x`, `rx`, `ry`, and `rz`.
+    to generate a controlled version. Currently, these are ``x``, ``rx``, ``ry``, and ``rz``.
     If a method is not directly known, it calls the unroller to convert to `u1`, `u3`,
     and `cx` gates.
 

qiskit/circuit/annotated_operation.py

@@ -18,6 +18,7 @@ import dataclasses
 from typing import Union, List
 
 from qiskit.circuit.operation import Operation
+from qiskit.circuit.parameterexpression import ParameterValueType
 from qiskit.circuit._utils import _compute_control_matrix, _ctrl_state_to_int
 from qiskit.circuit.exceptions import CircuitError
 
@@ -132,7 +133,7 @@ class AnnotatedOperation(Operation):
 
     def copy(self) -> "AnnotatedOperation":
         """Return a copy of the :class:`~.AnnotatedOperation`."""
-        return AnnotatedOperation(base_op=self.base_op, modifiers=self.modifiers.copy())
+        return AnnotatedOperation(base_op=self.base_op.copy(), modifiers=self.modifiers.copy())
 
     def to_matrix(self):
         """Return a matrix representation (allowing to construct Operator)."""
@@ -219,6 +220,27 @@ class AnnotatedOperation(Operation):
         extended_modifiers.append(PowerModifier(exponent))
         return AnnotatedOperation(self.base_op, extended_modifiers)
 
+    @property
+    def params(self) -> list[ParameterValueType]:
+        """The params of the underlying base operation."""
+        return getattr(self.base_op, "params", [])
+
+    @params.setter
+    def params(self, value: list[ParameterValueType]):
+        if hasattr(self.base_op, "params"):
+            self.base_op.params = value
+        else:
+            raise AttributeError(
+                f"Cannot set attribute ``params`` on the base operation {self.base_op}."
+            )
+
+    def validate_parameter(self, parameter: ParameterValueType) -> ParameterValueType:
+        """Validate a parameter for the underlying base operation."""
+        if hasattr(self.base_op, "validate_parameter"):
+            return self.base_op.validate_parameter(parameter)
+
+        raise AttributeError(f"Cannot validate parameters on the base operation {self.base_op}.")
+
 
 def _canonicalize_modifiers(modifiers):
     """

qiskit/circuit/classical/expr/expr.py

@@ -53,7 +53,7 @@ class Expr(abc.ABC):
     expressions, and it does not make sense to add more outside of Qiskit library code.
 
     All subclasses are responsible for setting their ``type`` attribute in their ``__init__``, and
-    should not call the parent initialiser."""
+    should not call the parent initializer."""
 
     __slots__ = ("type",)
 
@@ -193,7 +193,7 @@ class Var(Expr):
         return self
 
     def __deepcopy__(self, memo):
-        # ... as are all my consituent parts.
+        # ... as are all my constituent parts.
         return self
 
 
@@ -241,7 +241,7 @@ class Unary(Expr):
 
         # If adding opcodes, remember to add helper constructor functions in `constructors.py`.
         # The opcode integers should be considered a public interface; they are used by
-        # serialisation formats that may transfer data between different versions of Qiskit.
+        # serialization formats that may transfer data between different versions of Qiskit.
         BIT_NOT = 1
         """Bitwise negation. ``~operand``."""
         LOGIC_NOT = 2
@@ -309,7 +309,7 @@ class Binary(Expr):
 
         # If adding opcodes, remember to add helper constructor functions in `constructors.py`
         # The opcode integers should be considered a public interface; they are used by
-        # serialisation formats that may transfer data between different versions of Qiskit.
+        # serialization formats that may transfer data between different versions of Qiskit.
         BIT_AND = 1
         """Bitwise "and". ``lhs & rhs``."""
         BIT_OR = 2

qiskit/circuit/classical/expr/visitors.py

@@ -29,7 +29,7 @@ _T_co = typing.TypeVar("_T_co", covariant=True)
 
 class ExprVisitor(typing.Generic[_T_co]):
     """Base class for visitors to the :class:`Expr` tree.  Subclasses should override whichever of
-    the ``visit_*`` methods that they are able to handle, and should be organised such that
+    the ``visit_*`` methods that they are able to handle, and should be organized such that
     non-existent methods will never be called."""
 
     # The method names are self-explanatory and docstrings would just be noise.

qiskit/circuit/classical/types/__init__.py

@@ -40,7 +40,7 @@ literals ``True`` and ``False``), and unsigned integers (corresponding to
 .. autoclass:: Bool
 .. autoclass:: Uint
 
-Note that :class:`Uint` defines a family of types parametrised by their width; it is not one single
+Note that :class:`Uint` defines a family of types parametrized by their width; it is not one single
 type, which may be slightly different to the 'classical' programming languages you are used to.
 
 

qiskit/circuit/classical/types/types.py

@@ -29,7 +29,7 @@ import typing
 
 
 class _Singleton(type):
-    """Metaclass to make the child, which should take zero initialisation arguments, a singleton
+    """Metaclass to make the child, which should take zero initialization arguments, a singleton
     object."""
 
     def _get_singleton_instance(cls):
@@ -76,7 +76,7 @@ class Type:
     def __setstate__(self, state):
         _dict, slots = state
         for slot, value in slots.items():
-            # We need to overcome the type's enforcement of immutability post initialisation.
+            # We need to overcome the type's enforcement of immutability post initialization.
             super().__setattr__(slot, value)
 
 

qiskit/circuit/classicalfunction/__init__.py

@@ -51,6 +51,14 @@ QuantumCircuit:
 Following Qiskit's little-endian bit ordering convention, the left-most bit (``a``) is the most
 significant bit and the right-most bit (``d``) is the least significant bit.
 
+.. warning::
+
+    The functionality of `qiskit.circuit.classicalfunction` requires `tweedledum`, 
+    which isn't available on all platforms (up to Python version 3.11).
+    See `tweedledum installation guide 
+    <https://github.com/boschmitt/tweedledum/tree/master?tab=readme-ov-file#installation>`_ 
+    for more details.
+
 Supplementary Information
 =========================