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

qiskit/circuit/quantumcircuit.py

@@ -15,6 +15,8 @@
 """Quantum circuit object."""
 
 from __future__ import annotations
+
+import collections.abc
 import copy as _copy
 import itertools
 import multiprocessing as mp
@@ -37,14 +39,15 @@ from typing import (
 )
 import numpy as np
 from qiskit._accelerate.circuit import CircuitData
+from qiskit._accelerate.circuit import StandardGate
 from qiskit.exceptions import QiskitError
 from qiskit.utils.multiprocessing import is_main_process
 from qiskit.circuit.instruction import Instruction
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.parameter import Parameter
 from qiskit.circuit.exceptions import CircuitError
+from qiskit.utils import deprecate_func
 from . import _classical_resource_map
-from ._utils import sort_parameters
 from .controlflow import ControlFlowOp, _builder_utils
 from .controlflow.builder import CircuitScopeInterface, ControlFlowBuilderBlock
 from .controlflow.break_loop import BreakLoopOp, BreakLoopPlaceholder
@@ -57,7 +60,7 @@ from .classical import expr, types
 from .parameterexpression import ParameterExpression, ParameterValueType
 from .quantumregister import QuantumRegister, Qubit, AncillaRegister, AncillaQubit
 from .classicalregister import ClassicalRegister, Clbit
-from .parametertable import ParameterReferences, ParameterTable, ParameterView
+from .parametertable import ParameterView
 from .parametervector import ParameterVector
 from .instructionset import InstructionSet
 from .operation import Operation
@@ -110,7 +113,7 @@ BitType = TypeVar("BitType", Qubit, Clbit)
 #
 # If you're adding methods or attributes to `QuantumCircuit`, be sure to update the class docstring
 # to document them in a suitable place.  The class is huge, so we do its documentation manually so
-# it has at least some amount of organisational structure.
+# it has at least some amount of organizational structure.
 
 
 class QuantumCircuit:
@@ -368,7 +371,7 @@ class QuantumCircuit:
     -------------------------------
 
     A :class:`.Bit` instance is, on its own, just a unique handle for circuits to use in their own
-    contexts.  If you have got a :class:`.Bit` instance and a cirucit, just can find the contexts
+    contexts.  If you have got a :class:`.Bit` instance and a circuit, just can find the contexts
     that the bit exists in using :meth:`find_bit`, such as its integer index in the circuit and any
     registers it is contained in.
 
@@ -649,7 +652,7 @@ class QuantumCircuit:
 
     Finally, these methods apply particular generalized multiply controlled gates to the circuit,
     often with eager syntheses.  They are listed in terms of the *base* gate they are controlling,
-    since their exact output is often a synthesised version of a gate.
+    since their exact output is often a synthesized version of a gate.
 
     ===============================   =================================================
     :class:`QuantumCircuit` method    Base :mod:`qiskit.circuit.library` :class:`.Gate`
@@ -1066,8 +1069,9 @@ class QuantumCircuit:
 
             if not valid_reg_size:
                 raise CircuitError(
-                    "Circuit args must be Registers or integers. (%s '%s' was "
-                    "provided)" % ([type(reg).__name__ for reg in regs], regs)
+                    "Circuit args must be Registers or integers. ("
+                    f"{[type(reg).__name__ for reg in regs]} '{regs}' was "
+                    "provided)"
                 )
 
             regs = tuple(int(reg) for reg in regs)  # cast to int
@@ -1075,7 +1079,7 @@ class QuantumCircuit:
         self.name: str
         """A human-readable name for the circuit."""
         if name is None:
-            self._base_name = self.cls_prefix()
+            self._base_name = self._cls_prefix()
             self._name_update()
         elif not isinstance(name, str):
             raise CircuitError(
@@ -1124,14 +1128,7 @@ class QuantumCircuit:
         self._calibrations: DefaultDict[str, dict[tuple, Any]] = defaultdict(dict)
         self.add_register(*regs)
 
-        # Parameter table tracks instructions with variable parameters.
-        self._parameter_table = ParameterTable()
-
-        # Cache to avoid re-sorting parameters
-        self._parameters = None
-
         self._layout = None
-        self._global_phase: ParameterValueType = 0
         self.global_phase = global_phase
 
         # Add classical variables.  Resolve inputs and captures first because they can't depend on
@@ -1159,6 +1156,15 @@ class QuantumCircuit:
         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:
+        """A private constructor from rust space circuit data."""
+        out = QuantumCircuit()
+        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
     def from_instructions(
         instructions: Iterable[
@@ -1258,8 +1264,6 @@ class QuantumCircuit:
         else:
             data_input = list(data_input)
         self._data.clear()
-        self._parameters = None
-        self._parameter_table = ParameterTable()
         # Repopulate the parameter table with any global-phase entries.
         self.global_phase = self.global_phase
         if not data_input:
@@ -1382,12 +1386,11 @@ class QuantumCircuit:
 
         # Avoids pulling self._data into a Python list
         # like we would when pickling.
-        result._data = self._data.copy()
+        result._data = self._data.copy(deepcopy=True)
         result._data.replace_bits(
             qubits=_copy.deepcopy(self._data.qubits, memo),
             clbits=_copy.deepcopy(self._data.clbits, memo),
         )
-        result._data.map_ops(lambda op: _copy.deepcopy(op, memo))
         return result
 
     @classmethod
@@ -1395,16 +1398,39 @@ class QuantumCircuit:
         cls.instances += 1
 
     @classmethod
+    @deprecate_func(
+        since=1.2,
+        removal_timeline="in the 2.0 release",
+        additional_msg="This method is only used as an internal helper "
+        "and will be removed with no replacement.",
+    )
     def cls_instances(cls) -> int:
         """Return the current number of instances of this class,
         useful for auto naming."""
         return cls.instances
 
     @classmethod
+    def _cls_instances(cls) -> int:
+        """Return the current number of instances of this class,
+        useful for auto naming."""
+        return cls.instances
+
+    @classmethod
+    @deprecate_func(
+        since=1.2,
+        removal_timeline="in the 2.0 release",
+        additional_msg="This method is only used as an internal helper "
+        "and will be removed with no replacement.",
+    )
     def cls_prefix(cls) -> str:
         """Return the prefix to use for auto naming."""
         return cls.prefix
 
+    @classmethod
+    def _cls_prefix(cls) -> str:
+        """Return the prefix to use for auto naming."""
+        return cls.prefix
+
     def _name_update(self) -> None:
         """update name of instance using instance number"""
         if not is_main_process():
@@ -1412,7 +1438,7 @@ class QuantumCircuit:
         else:
             pid_name = ""
 
-        self.name = f"{self._base_name}-{self.cls_instances()}{pid_name}"
+        self.name = f"{self._base_name}-{self._cls_instances()}{pid_name}"
 
     def has_register(self, register: Register) -> bool:
         """
@@ -1591,11 +1617,12 @@ class QuantumCircuit:
             )
         return inverse_circ
 
-    def repeat(self, reps: int) -> "QuantumCircuit":
+    def repeat(self, reps: int, *, insert_barriers: bool = False) -> "QuantumCircuit":
         """Repeat this circuit ``reps`` times.
 
         Args:
             reps (int): How often this circuit should be repeated.
+            insert_barriers (bool): Whether to include barriers between circuit repetitions.
 
         Returns:
             QuantumCircuit: A circuit containing ``reps`` repetitions of this circuit.
@@ -1611,8 +1638,10 @@ class QuantumCircuit:
                 inst: Instruction = self.to_gate()
             except QiskitError:
                 inst = self.to_instruction()
-            for _ in range(reps):
+            for i in range(reps):
                 repeated_circ._append(inst, self.qubits, self.clbits)
+                if insert_barriers and i != reps - 1:
+                    repeated_circ.barrier()
 
         return repeated_circ
 
@@ -1655,7 +1684,7 @@ class QuantumCircuit:
             raise CircuitError(
                 "Cannot raise a parameterized circuit to a non-positive power "
                 "or matrix-power, please bind the free parameters: "
-                "{}".format(self.parameters)
+                f"{self.parameters}"
             )
 
         try:
@@ -1685,7 +1714,7 @@ class QuantumCircuit:
             label (str): An optional label to give the controlled operation for visualization.
             ctrl_state (str or int): The control state in decimal or as a bitstring
                 (e.g. '111'). If None, use ``2**num_ctrl_qubits - 1``.
-            annotated: indicates whether the controlled gate can be implemented
+            annotated: indicates whether the controlled gate should be implemented
                 as an annotated gate.
 
         Returns:
@@ -1757,14 +1786,14 @@ class QuantumCircuit:
                 this can be anything that :obj:`.append` will accept.
             qubits (list[Qubit|int]): qubits of self to compose onto.
             clbits (list[Clbit|int]): clbits of self to compose onto.
-            front (bool): If True, front composition will be performed.  This is not possible within
+            front (bool): If ``True``, front composition will be performed.  This is not possible within
                 control-flow builder context managers.
-            inplace (bool): If True, modify the object. Otherwise return composed circuit.
+            inplace (bool): If ``True``, modify the object. Otherwise, return composed circuit.
             copy (bool): If ``True`` (the default), then the input is treated as shared, and any
                 contained instructions will be copied, if they might need to be mutated in the
                 future.  You can set this to ``False`` if the input should be considered owned by
                 the base circuit, in order to avoid unnecessary copies; in this case, it is not
-                valid to use ``other`` afterwards, and some instructions may have been mutated in
+                valid to use ``other`` afterward, and some instructions may have been mutated in
                 place.
             var_remap (Mapping): mapping to use to rewrite :class:`.expr.Var` nodes in ``other`` as
                 they are inlined into ``self``.  This can be used to avoid naming conflicts.
@@ -1896,7 +1925,7 @@ class QuantumCircuit:
                 clbits = self.clbits[: other.num_clbits]
             if front:
                 # Need to keep a reference to the data for use after we've emptied it.
-                old_data = dest._data.copy()
+                old_data = dest._data.copy(copy_instructions=copy)
                 dest.clear()
                 dest.append(other, qubits, clbits, copy=copy)
                 for instruction in old_data:
@@ -1918,11 +1947,11 @@ class QuantumCircuit:
             mapped_qubits = dest.qubits
             edge_map.update(zip(other.qubits, dest.qubits))
         else:
-            mapped_qubits = dest.qbit_argument_conversion(qubits)
-            if len(mapped_qubits) != len(other.qubits):
+            mapped_qubits = dest._qbit_argument_conversion(qubits)
+            if len(mapped_qubits) != other.num_qubits:
                 raise CircuitError(
                     f"Number of items in qubits parameter ({len(mapped_qubits)}) does not"
-                    f" match number of qubits in the circuit ({len(other.qubits)})."
+                    f" match number of qubits in the circuit ({other.num_qubits})."
                 )
             if len(set(mapped_qubits)) != len(mapped_qubits):
                 raise CircuitError(
@@ -1934,17 +1963,17 @@ class QuantumCircuit:
             mapped_clbits = dest.clbits
             edge_map.update(zip(other.clbits, dest.clbits))
         else:
-            mapped_clbits = dest.cbit_argument_conversion(clbits)
-            if len(mapped_clbits) != len(other.clbits):
+            mapped_clbits = dest._cbit_argument_conversion(clbits)
+            if len(mapped_clbits) != other.num_clbits:
                 raise CircuitError(
                     f"Number of items in clbits parameter ({len(mapped_clbits)}) does not"
-                    f" match number of clbits in the circuit ({len(other.clbits)})."
+                    f" match number of clbits in the circuit ({other.num_clbits})."
                 )
             if len(set(mapped_clbits)) != len(mapped_clbits):
                 raise CircuitError(
                     f"Duplicate clbits referenced in 'clbits' parameter: '{mapped_clbits}'"
                 )
-            edge_map.update(zip(other.clbits, dest.cbit_argument_conversion(clbits)))
+            edge_map.update(zip(other.clbits, dest._cbit_argument_conversion(clbits)))
 
         for gate, cals in other.calibrations.items():
             dest._calibrations[gate].update(cals)
@@ -2024,14 +2053,14 @@ class QuantumCircuit:
                     )
                 return n_op.copy() if n_op is op and copy else n_op
 
-            instructions = source._data.copy()
+            instructions = source._data.copy(copy_instructions=copy)
             instructions.replace_bits(qubits=new_qubits, clbits=new_clbits)
-            instructions.map_ops(map_vars)
+            instructions.map_nonstandard_ops(map_vars)
             dest._current_scope().extend(instructions)
 
         append_existing = None
         if front:
-            append_existing = dest._data.copy()
+            append_existing = dest._data.copy(copy_instructions=copy)
             dest.clear()
         copy_with_remapping(
             other,
@@ -2068,7 +2097,7 @@ class QuantumCircuit:
 
         Args:
             other (QuantumCircuit): The other circuit to tensor this circuit with.
-            inplace (bool): If True, modify the object. Otherwise return composed circuit.
+            inplace (bool): If ``True``, modify the object. Otherwise return composed circuit.
 
         Examples:
 
@@ -2084,7 +2113,7 @@ class QuantumCircuit:
                tensored.draw('mpl')
 
         Returns:
-            QuantumCircuit: The tensored circuit (returns None if inplace==True).
+            QuantumCircuit: The tensored circuit (returns ``None`` if ``inplace=True``).
         """
         num_qubits = self.num_qubits + other.num_qubits
         num_clbits = self.num_clbits + other.num_clbits
@@ -2259,6 +2288,12 @@ class QuantumCircuit:
         return self._data[item]
 
     @staticmethod
+    @deprecate_func(
+        since=1.2,
+        removal_timeline="in the 2.0 release",
+        additional_msg="This method is only used as an internal helper "
+        "and will be removed with no replacement.",
+    )
     def cast(value: S, type_: Callable[..., T]) -> Union[S, T]:
         """Best effort to cast value to type. Otherwise, returns the value."""
         try:
@@ -2266,36 +2301,108 @@ class QuantumCircuit:
         except (ValueError, TypeError):
             return value
 
+    @staticmethod
+    def _cast(value: S, type_: Callable[..., T]) -> Union[S, T]:
+        """Best effort to cast value to type. Otherwise, returns the value."""
+        try:
+            return type_(value)
+        except (ValueError, TypeError):
+            return value
+
+    @deprecate_func(
+        since=1.2,
+        removal_timeline="in the 2.0 release",
+        additional_msg="This method is only used as an internal helper "
+        "and will be removed with no replacement.",
+    )
     def qbit_argument_conversion(self, qubit_representation: QubitSpecifier) -> list[Qubit]:
         """
         Converts several qubit representations (such as indexes, range, etc.)
         into a list of qubits.
 
         Args:
-            qubit_representation (Object): representation to expand
+            qubit_representation: Representation to expand.
+
+        Returns:
+            The resolved instances of the qubits.
+        """
+
+        return self._qbit_argument_conversion(qubit_representation)
+
+    def _qbit_argument_conversion(self, qubit_representation: QubitSpecifier) -> list[Qubit]:
+        """
+        Converts several qubit representations (such as indexes, range, etc.)
+        into a list of qubits.
+
+        Args:
+            qubit_representation: Representation to expand.
 
         Returns:
-            List(Qubit): the resolved instances of the qubits.
+            The resolved instances of the qubits.
         """
         return _bit_argument_conversion(
             qubit_representation, self.qubits, self._qubit_indices, Qubit
         )
 
+    @deprecate_func(
+        since=1.2,
+        removal_timeline="in the 2.0 release",
+        additional_msg="This method is only used as an internal helper "
+        "and will be removed with no replacement.",
+    )
     def cbit_argument_conversion(self, clbit_representation: ClbitSpecifier) -> list[Clbit]:
         """
         Converts several classical bit representations (such as indexes, range, etc.)
         into a list of classical bits.
 
         Args:
-            clbit_representation (Object): representation to expand
+            clbit_representation : Representation to expand.
+
+        Returns:
+            A list of tuples where each tuple is a classical bit.
+        """
+        return self._cbit_argument_conversion(clbit_representation)
+
+    def _cbit_argument_conversion(self, clbit_representation: ClbitSpecifier) -> list[Clbit]:
+        """
+        Converts several classical bit representations (such as indexes, range, etc.)
+        into a list of classical bits.
+
+        Args:
+            clbit_representation: Representation to expand.
 
         Returns:
-            List(tuple): Where each tuple is a classical bit.
+            A list of tuples where each tuple is a classical bit.
         """
         return _bit_argument_conversion(
             clbit_representation, self.clbits, self._clbit_indices, Clbit
         )
 
+    def _append_standard_gate(
+        self,
+        op: StandardGate,
+        qargs: Sequence[QubitSpecifier] = (),
+        params: Sequence[ParameterValueType] = (),
+        label: str | None = None,
+    ) -> InstructionSet:
+        """An internal method to bypass some checking when directly appending a standard gate."""
+        circuit_scope = self._current_scope()
+
+        if params is None:
+            params = []
+
+        expanded_qargs = [self._qbit_argument_conversion(qarg) for qarg in qargs or []]
+        for param in params:
+            Gate.validate_parameter(op, param)
+
+        instructions = InstructionSet(resource_requester=circuit_scope.resolve_classical_resource)
+        for qarg, _ in Gate.broadcast_arguments(op, expanded_qargs, []):
+            self._check_dups(qarg)
+            instruction = CircuitInstruction.from_standard(op, qarg, params, label=label)
+            circuit_scope.append(instruction, _standard_gate=True)
+            instructions._add_ref(circuit_scope.instructions, len(circuit_scope.instructions) - 1)
+        return instructions
+
     def append(
         self,
         instruction: Operation | CircuitInstruction,
@@ -2383,8 +2490,8 @@ class QuantumCircuit:
                     " which are not in this circuit"
                 )
 
-        expanded_qargs = [self.qbit_argument_conversion(qarg) for qarg in qargs or []]
-        expanded_cargs = [self.cbit_argument_conversion(carg) for carg in cargs or []]
+        expanded_qargs = [self._qbit_argument_conversion(qarg) for qarg in qargs or []]
+        expanded_cargs = [self._cbit_argument_conversion(carg) for carg in cargs or []]
 
         instructions = InstructionSet(resource_requester=circuit_scope.resolve_classical_resource)
         # For Operations that are non-Instructions, we use the Instruction's default method
@@ -2393,16 +2500,19 @@ class QuantumCircuit:
             if isinstance(operation, Instruction)
             else Instruction.broadcast_arguments(operation, expanded_qargs, expanded_cargs)
         )
+        base_instruction = CircuitInstruction(operation, (), ())
         for qarg, carg in broadcast_iter:
             self._check_dups(qarg)
-            instruction = CircuitInstruction(operation, qarg, carg)
+            instruction = base_instruction.replace(qubits=qarg, clbits=carg)
             circuit_scope.append(instruction)
             instructions._add_ref(circuit_scope.instructions, len(circuit_scope.instructions) - 1)
         return instructions
 
     # Preferred new style.
     @typing.overload
-    def _append(self, instruction: CircuitInstruction) -> CircuitInstruction: ...
+    def _append(
+        self, instruction: CircuitInstruction, *, _standard_gate: bool
+    ) -> CircuitInstruction: ...
 
     # To-be-deprecated old style.
     @typing.overload
@@ -2413,7 +2523,7 @@ class QuantumCircuit:
         cargs: Sequence[Clbit],
     ) -> Operation: ...
 
-    def _append(self, instruction, qargs=(), cargs=()):
+    def _append(self, instruction, qargs=(), cargs=(), *, _standard_gate: bool = False):
         """Append an instruction to the end of the circuit, modifying the circuit in place.
 
         .. warning::
@@ -2435,7 +2545,7 @@ class QuantumCircuit:
             and the only reference to the circuit the instructions are being appended to is within
             that same function.  In particular, it is not safe to call
             :meth:`QuantumCircuit._append` on a circuit that is received by a function argument.
-            This is because :meth:`.QuantumCircuit._append` will not recognise the scoping
+            This is because :meth:`.QuantumCircuit._append` will not recognize the scoping
             constructs of the control-flow builder interface.
 
         Args:
@@ -2454,40 +2564,34 @@ class QuantumCircuit:
 
         :meta public:
         """
+        if _standard_gate:
+            self._data.append(instruction)
+            self.duration = None
+            self.unit = "dt"
+            return instruction
+
         old_style = not isinstance(instruction, CircuitInstruction)
         if old_style:
             instruction = CircuitInstruction(instruction, qargs, cargs)
-        self._data.append(instruction)
-        self._track_operation(instruction.operation)
-        return instruction.operation if old_style else instruction
-
-    def _track_operation(self, operation: Operation):
-        """Sync all non-data-list internal data structures for a newly tracked operation."""
-        if isinstance(operation, Instruction):
-            self._update_parameter_table(operation)
+        # If there is a reference to the outer circuit in an
+        # instruction param the inner rust append method will raise a runtime error.
+        # When this happens we need to handle the parameters separately.
+        # This shouldn't happen in practice but 2 tests were doing this and it's not
+        # explicitly prohibted by the API.
+        try:
+            self._data.append(instruction)
+        except RuntimeError:
+            params = [
+                (idx, param.parameters)
+                for idx, param in enumerate(instruction.operation.params)
+                if isinstance(param, (ParameterExpression, QuantumCircuit))
+            ]
+            self._data.append_manual_params(instruction, params)
+
+        # Invalidate whole circuit duration if an instruction is added
         self.duration = None
         self.unit = "dt"
-
-    def _update_parameter_table(self, instruction: Instruction):
-        for param_index, param in enumerate(instruction.params):
-            if isinstance(param, (ParameterExpression, QuantumCircuit)):
-                # Scoped constructs like the control-flow ops use QuantumCircuit as a parameter.
-                atomic_parameters = set(param.parameters)
-            else:
-                atomic_parameters = set()
-
-            for parameter in atomic_parameters:
-                if parameter in self._parameter_table:
-                    self._parameter_table[parameter].add((instruction, param_index))
-                else:
-                    if parameter.name in self._parameter_table.get_names():
-                        raise CircuitError(f"Name conflict on adding parameter: {parameter.name}")
-                    self._parameter_table[parameter] = ParameterReferences(
-                        ((instruction, param_index),)
-                    )
-
-                    # clear cache if new parameter is added
-                    self._parameters = None
+        return instruction.operation if old_style else instruction
 
     @typing.overload
     def get_parameter(self, name: str, default: T) -> Union[Parameter, T]: ...
@@ -2518,7 +2622,7 @@ class QuantumCircuit:
 
                 my_param = Parameter("my_param")
 
-                # Create a parametrised circuit.
+                # Create a parametrized circuit.
                 qc = QuantumCircuit(1)
                 qc.rx(my_param, 0)
 
@@ -2538,7 +2642,7 @@ class QuantumCircuit:
                 A similar method, but for :class:`.expr.Var` run-time variables instead of
                 :class:`.Parameter` compile-time parameters.
         """
-        if (parameter := self._parameter_table.parameter_from_name(name, None)) is None:
+        if (parameter := self._data.get_parameter_by_name(name)) is None:
             if default is Ellipsis:
                 raise KeyError(f"no parameter named '{name}' is present")
             return default
@@ -2734,8 +2838,8 @@ class QuantumCircuit:
                 # two classical registers we measured into above.
                 qc.add_var(my_var, expr.bit_and(cr1, cr2))
         """
-        # Validate the initialiser first to catch cases where the variable to be declared is being
-        # used in the initialiser.
+        # Validate the initializer first to catch cases where the variable to be declared is being
+        # used in the initializer.
         circuit_scope = self._current_scope()
         # Convenience method to widen Python integer literals to the right width during the initial
         # lift, if the type is already known via the variable.
@@ -2759,7 +2863,7 @@ class QuantumCircuit:
             var = name_or_var
         circuit_scope.add_uninitialized_var(var)
         try:
-            # Store is responsible for ensuring the type safety of the initialisation.
+            # Store is responsible for ensuring the type safety of the initialization.
             store = Store(var, initial)
         except CircuitError:
             circuit_scope.remove_var(var)
@@ -2789,7 +2893,7 @@ class QuantumCircuit:
         # name, and to be a bit less ergonomic than `add_var` (i.e. not allowing the (name, type)
         # overload) to discourage people from using it when they should use `add_var`.
         #
-        # This function exists so that there is a method to emulate `copy_empty_like`'s behaviour of
+        # This function exists so that there is a method to emulate `copy_empty_like`'s behavior of
         # adding uninitialised variables, which there's no obvious way around.  We need to be sure
         # that _some_ sort of handling of uninitialised variables is taken into account in our
         # structures, so that doesn't become a huge edge case, even though we make no assertions
@@ -2823,7 +2927,7 @@ class QuantumCircuit:
         """
         if self._control_flow_scopes:
             # Allow manual capturing.  Not sure why it'd be useful, but there's a clear expected
-            # behaviour here.
+            # behavior here.
             self._control_flow_scopes[-1].use_var(var)
             return
         if self._vars_input:
@@ -2894,14 +2998,14 @@ class QuantumCircuit:
                 raise CircuitError(
                     "QuantumCircuit parameters can be Registers or Integers."
                     " If Integers, up to 2 arguments. QuantumCircuit was called"
-                    " with %s." % (regs,)
+                    f" with {(regs,)}."
                 )
 
         for register in regs:
             if isinstance(register, Register) and any(
                 register.name == reg.name for reg in self.qregs + self.cregs
             ):
-                raise CircuitError('register name "%s" already exists' % register.name)
+                raise CircuitError(f'register name "{register.name}" already exists')
 
             if isinstance(register, AncillaRegister):
                 for bit in register:
@@ -2917,7 +3021,7 @@ class QuantumCircuit:
                     else:
                         self._data.add_qubit(bit)
                         self._qubit_indices[bit] = BitLocations(
-                            len(self._data.qubits) - 1, [(register, idx)]
+                            self._data.num_qubits - 1, [(register, idx)]
                         )
 
             elif isinstance(register, ClassicalRegister):
@@ -2929,7 +3033,7 @@ class QuantumCircuit:
                     else:
                         self._data.add_clbit(bit)
                         self._clbit_indices[bit] = BitLocations(
-                            len(self._data.clbits) - 1, [(register, idx)]
+                            self._data.num_clbits - 1, [(register, idx)]
                         )
 
             elif isinstance(register, list):
@@ -2950,14 +3054,14 @@ class QuantumCircuit:
                 self._ancillas.append(bit)
             if isinstance(bit, Qubit):
                 self._data.add_qubit(bit)
-                self._qubit_indices[bit] = BitLocations(len(self._data.qubits) - 1, [])
+                self._qubit_indices[bit] = BitLocations(self._data.num_qubits - 1, [])
             elif isinstance(bit, Clbit):
                 self._data.add_clbit(bit)
-                self._clbit_indices[bit] = BitLocations(len(self._data.clbits) - 1, [])
+                self._clbit_indices[bit] = BitLocations(self._data.num_clbits - 1, [])
             else:
                 raise CircuitError(
                     "Expected an instance of Qubit, Clbit, or "
-                    "AncillaQubit, but was passed {}".format(bit)
+                    f"AncillaQubit, but was passed {bit}"
                 )
 
     def find_bit(self, bit: Bit) -> BitLocations:
@@ -3126,7 +3230,7 @@ class QuantumCircuit:
         reverse_bits: bool | None = None,
         justify: str | None = None,
         vertical_compression: str | None = "medium",
-        idle_wires: bool = True,
+        idle_wires: bool | None = None,
         with_layout: bool = True,
         fold: int | None = None,
         # The type of ax is matplotlib.axes.Axes, but this is not a fixed dependency, so cannot be
@@ -3157,7 +3261,7 @@ class QuantumCircuit:
         Args:
             output: Select the output method to use for drawing the circuit.
                 Valid choices are ``text``, ``mpl``, ``latex``, ``latex_source``.
-                By default the `text` drawer is used unless the user config file
+                By default, the ``text`` drawer is used unless the user config file
                 (usually ``~/.qiskit/settings.conf``) has an alternative backend set
                 as the default. For example, ``circuit_drawer = latex``. If the output
                 kwarg is set, that backend will always be used over the default in
@@ -3193,17 +3297,19 @@ class QuantumCircuit:
                 alternative value set. For example, ``circuit_reverse_bits = True``.
             plot_barriers: Enable/disable drawing barriers in the output
                 circuit. Defaults to ``True``.
-            justify: Options are ``left``, ``right`` or ``none``. If
-                anything else is supplied, it defaults to left justified. It refers
-                to where gates should be placed in the output circuit if there is
-                an option. ``none`` results in each gate being placed in its own
-                column.
+            justify: Options are ``"left"``, ``"right"`` or ``"none"`` (str).
+                If anything else is supplied, left justified will be used instead.
+                It refers to where gates should be placed in the output circuit if
+                there is an option. ``none`` results in each gate being placed in
+                its own column. Defaults to ``left``.
             vertical_compression: ``high``, ``medium`` or ``low``. It
                 merges the lines generated by the `text` output so the drawing
                 will take less vertical room.  Default is ``medium``. Only used by
                 the ``text`` output, will be silently ignored otherwise.
             idle_wires: Include idle wires (wires with no circuit elements)
-                in output visualization. Default is ``True``.
+                in output visualization. Default is ``True`` unless the
+                user config file (usually ``~/.qiskit/settings.conf``) has an
+                alternative value set. For example, ``circuit_idle_wires = False``.
             with_layout: Include layout information, with labels on the
                 physical layout. Default is ``True``.
             fold: Sets pagination. It can be disabled using -1. In ``text``,
@@ -3292,7 +3398,7 @@ class QuantumCircuit:
         Args:
             filter_function (callable): a function to filter out some instructions.
                 Should take as input a tuple of (Instruction, list(Qubit), list(Clbit)).
-                By default filters out "directives", such as barrier or snapshot.
+                By default, filters out "directives", such as barrier or snapshot.
 
         Returns:
             int: Total number of gate operations.
@@ -3314,7 +3420,7 @@ class QuantumCircuit:
             filter_function: A function to decide which instructions count to increase depth.
                 Should take as a single positional input a :class:`CircuitInstruction`.
                 Instructions for which the function returns ``False`` are ignored in the
-                computation of the circuit depth.  By default filters out "directives", such as
+                computation of the circuit depth.  By default, filters out "directives", such as
                 :class:`.Barrier`.
 
         Returns:
@@ -3377,12 +3483,12 @@ class QuantumCircuit:
             int: Width of circuit.
 
         """
-        return len(self.qubits) + len(self.clbits)
+        return self._data.width()
 
     @property
     def num_qubits(self) -> int:
         """Return number of qubits."""
-        return len(self.qubits)
+        return self._data.num_qubits
 
     @property
     def num_ancillas(self) -> int:
@@ -3392,7 +3498,7 @@ class QuantumCircuit:
     @property
     def num_clbits(self) -> int:
         """Return number of classical bits."""
-        return len(self.clbits)
+        return self._data.num_clbits
 
     # The stringified return type is because OrderedDict can't be subscripted before Python 3.9, and
     # typing.OrderedDict wasn't added until 3.7.2.  It can be turned into a proper type once 3.6
@@ -3413,13 +3519,7 @@ class QuantumCircuit:
 
         Conditional nonlocal gates are also included.
         """
-        multi_qubit_gates = 0
-        for instruction in self._data:
-            if instruction.operation.num_qubits > 1 and not getattr(
-                instruction.operation, "_directive", False
-            ):
-                multi_qubit_gates += 1
-        return multi_qubit_gates
+        return self._data.num_nonlocal_gates()
 
     def get_instructions(self, name: str) -> list[CircuitInstruction]:
         """Get instructions matching name.
@@ -3445,7 +3545,7 @@ class QuantumCircuit:
         bits = self.qubits if unitary_only else (self.qubits + self.clbits)
         bit_indices: dict[Qubit | Clbit, int] = {bit: idx for idx, bit in enumerate(bits)}
 
-        # Start with each qubit or cbit being its own subgraph.
+        # Start with each qubit or clbit being its own subgraph.
         sub_graphs = [[bit] for bit in range(len(bit_indices))]
 
         num_sub_graphs = len(sub_graphs)
@@ -3533,29 +3633,6 @@ class QuantumCircuit:
         """
         cpy = self.copy_empty_like(name)
         cpy._data = self._data.copy()
-
-        # The special global-phase sentinel doesn't need copying, but it's
-        # added here to ensure it's recognised. The global phase itself was
-        # already copied over in `copy_empty_like`.
-        operation_copies = {id(ParameterTable.GLOBAL_PHASE): ParameterTable.GLOBAL_PHASE}
-
-        def memo_copy(op):
-            if (out := operation_copies.get(id(op))) is not None:
-                return out
-            copied = op.copy()
-            operation_copies[id(op)] = copied
-            return copied
-
-        cpy._data.map_ops(memo_copy)
-        cpy._parameter_table = ParameterTable(
-            {
-                param: ParameterReferences(
-                    (operation_copies[id(operation)], param_index)
-                    for operation, param_index in self._parameter_table[param]
-                )
-                for param in self._parameter_table
-            }
-        )
         return cpy
 
     def copy_empty_like(
@@ -3619,7 +3696,7 @@ class QuantumCircuit:
         if vars_mode == "alike":
             # Note that this causes the local variables to be uninitialised, because the stores are
             # not copied.  This can leave the circuit in a potentially dangerous state for users if
-            # they don't re-add initialiser stores.
+            # they don't re-add initializer stores.
             cpy._vars_local = self._vars_local.copy()
             cpy._vars_input = self._vars_input.copy()
             cpy._vars_capture = self._vars_capture.copy()
@@ -3634,14 +3711,9 @@ class QuantumCircuit:
         else:  # pragma: no cover
             raise ValueError(f"unknown vars_mode: '{vars_mode}'")
 
-        cpy._parameter_table = ParameterTable()
-        for parameter in getattr(cpy.global_phase, "parameters", ()):
-            cpy._parameter_table[parameter] = ParameterReferences(
-                [(ParameterTable.GLOBAL_PHASE, None)]
-            )
-        cpy._data = CircuitData(self._data.qubits, self._data.clbits)
-        # Invalidate parameters caching.
-        cpy._parameters = None
+        cpy._data = CircuitData(
+            self._data.qubits, self._data.clbits, global_phase=self._data.global_phase
+        )
 
         cpy._calibrations = _copy.deepcopy(self._calibrations)
         cpy._metadata = _copy.deepcopy(self._metadata)
@@ -3661,7 +3733,6 @@ class QuantumCircuit:
                 quantum and classical typed data, but without mutating the original circuit.
         """
         self._data.clear()
-        self._parameter_table.clear()
         # Repopulate the parameter table with any phase symbols.
         self.global_phase = self.global_phase
 
@@ -3818,7 +3889,7 @@ class QuantumCircuit:
             inplace (bool): All measurements inplace or return new circuit.
 
         Returns:
-            QuantumCircuit: Returns circuit with measurements when `inplace = False`.
+            QuantumCircuit: Returns circuit with measurements when ``inplace = False``.
         """
         from qiskit.converters.circuit_to_dag import circuit_to_dag
 
@@ -3865,18 +3936,18 @@ class QuantumCircuit:
         else:
             circ = self.copy()
         if add_bits:
-            new_creg = circ._create_creg(len(circ.qubits), "meas")
+            new_creg = circ._create_creg(circ.num_qubits, "meas")
             circ.add_register(new_creg)
             circ.barrier()
             circ.measure(circ.qubits, new_creg)
         else:
-            if len(circ.clbits) < len(circ.qubits):
+            if circ.num_clbits < circ.num_qubits:
                 raise CircuitError(
                     "The number of classical bits must be equal or greater than "
                     "the number of qubits."
                 )
             circ.barrier()
-            circ.measure(circ.qubits, circ.clbits[0 : len(circ.qubits)])
+            circ.measure(circ.qubits, circ.clbits[0 : circ.num_qubits])
 
         if not inplace:
             return circ
@@ -3945,10 +4016,9 @@ class QuantumCircuit:
         circ._clbit_indices = {}
 
         # Clear instruction info
-        circ._data = CircuitData(qubits=circ._data.qubits, reserve=len(circ._data))
-        circ._parameter_table.clear()
-        # Repopulate the parameter table with any global-phase entries.
-        circ.global_phase = circ.global_phase
+        circ._data = CircuitData(
+            qubits=circ._data.qubits, reserve=len(circ._data), global_phase=circ.global_phase
+        )
 
         # We must add the clbits first to preserve the original circuit
         # order. This way, add_register never adds clbits and just
@@ -4021,7 +4091,7 @@ class QuantumCircuit:
         """The global phase of the current circuit scope in radians."""
         if self._control_flow_scopes:
             return self._control_flow_scopes[-1].global_phase
-        return self._global_phase
+        return self._data.global_phase
 
     @global_phase.setter
     def global_phase(self, angle: ParameterValueType):
@@ -4030,25 +4100,10 @@ class QuantumCircuit:
         Args:
             angle (float, ParameterExpression): radians
         """
-        # If we're currently parametric, we need to throw away the references.  This setter is
-        # called by some subclasses before the inner `_global_phase` is initialised.
-        global_phase_reference = (ParameterTable.GLOBAL_PHASE, None)
-        if isinstance(previous := getattr(self, "_global_phase", None), ParameterExpression):
-            self._parameters = None
-            self._parameter_table.discard_references(previous, global_phase_reference)
-
-        if isinstance(angle, ParameterExpression) and angle.parameters:
-            for parameter in angle.parameters:
-                if parameter not in self._parameter_table:
-                    self._parameters = None
-                    self._parameter_table[parameter] = ParameterReferences(())
-                self._parameter_table[parameter].add(global_phase_reference)
-        else:
-            angle = _normalize_global_phase(angle)
         if self._control_flow_scopes:
             self._control_flow_scopes[-1].global_phase = angle
         else:
-            self._global_phase = angle
+            self._data.global_phase = angle
 
     @property
     def parameters(self) -> ParameterView:
@@ -4109,16 +4164,13 @@ class QuantumCircuit:
         Returns:
             The sorted :class:`.Parameter` objects in the circuit.
         """
-        # parameters from gates
-        if self._parameters is None:
-            self._parameters = sort_parameters(self._unsorted_parameters())
         # return as parameter view, which implements the set and list interface
-        return ParameterView(self._parameters)
+        return ParameterView(self._data.parameters)
 
     @property
     def num_parameters(self) -> int:
         """The number of parameter objects in the circuit."""
-        return len(self._parameter_table)
+        return self._data.num_parameters()
 
     def _unsorted_parameters(self) -> set[Parameter]:
         """Efficiently get all parameters in the circuit, without any sorting overhead.
@@ -4131,7 +4183,7 @@ class QuantumCircuit:
         """
         # This should be free, by accessing the actual backing data structure of the table, but that
         # means that we need to copy it if adding keys from the global phase.
-        return self._parameter_table.get_keys()
+        return self._data.unsorted_parameters()
 
     @overload
     def assign_parameters(
@@ -4244,94 +4296,28 @@ class QuantumCircuit:
         if inplace:
             target = self
         else:
+            if not isinstance(parameters, dict):
+                # We're going to need to access the sorted order wihin the inner Rust method on
+                # `target`, so warm up our own cache first so that subsequent calls to
+                # `assign_parameters` on `self` benefit as well.
+                _ = self._data.parameters
             target = self.copy()
             target._increment_instances()
             target._name_update()
 
-        # Normalise the inputs into simple abstract interfaces, so we've dispatched the "iteration"
-        # logic in one place at the start of the function.  This lets us do things like calculate
-        # and cache expensive properties for (e.g.) the sequence format only if they're used; for
-        # many large, close-to-hardware circuits, we won't need the extra handling for
-        # `global_phase` or recursive definition binding.
-        #
-        # During normalisation, be sure to reference 'parameters' and related things from 'self' not
-        # 'target' so we can take advantage of any caching we might be doing.
-        if isinstance(parameters, dict):
+        if isinstance(parameters, collections.abc.Mapping):
             raw_mapping = parameters if flat_input else self._unroll_param_dict(parameters)
-            # Remember that we _must not_ mutate the output of `_unsorted_parameters`.
-            our_parameters = self._unsorted_parameters()
+            our_parameters = self._data.unsorted_parameters()
             if strict and (extras := raw_mapping.keys() - our_parameters):
                 raise CircuitError(
                     f"Cannot bind parameters ({', '.join(str(x) for x in extras)}) not present in"
                     " the circuit."
                 )
             parameter_binds = _ParameterBindsDict(raw_mapping, our_parameters)
+            target._data.assign_parameters_mapping(parameter_binds)
         else:
-            our_parameters = self.parameters
-            if len(parameters) != len(our_parameters):
-                raise ValueError(
-                    "Mismatching number of values and parameters. For partial binding "
-                    "please pass a dictionary of {parameter: value} pairs."
-                )
-            parameter_binds = _ParameterBindsSequence(our_parameters, parameters)
-
-        # Clear out the parameter table for the relevant entries, since we'll be binding those.
-        # Any new references to parameters are reinserted as part of the bind.
-        target._parameters = None
-        # This is deliberately eager, because we want the side effect of clearing the table.
-        all_references = [
-            (parameter, value, target._parameter_table.pop(parameter, ()))
-            for parameter, value in parameter_binds.items()
-        ]
-        seen_operations = {}
-        # The meat of the actual binding for regular operations.
-        for to_bind, bound_value, references in all_references:
-            update_parameters = (
-                tuple(bound_value.parameters)
-                if isinstance(bound_value, ParameterExpression)
-                else ()
-            )
-            for operation, index in references:
-                seen_operations[id(operation)] = operation
-                if operation is ParameterTable.GLOBAL_PHASE:
-                    assignee = target.global_phase
-                    validate = _normalize_global_phase
-                else:
-                    assignee = operation.params[index]
-                    validate = operation.validate_parameter
-                if isinstance(assignee, ParameterExpression):
-                    new_parameter = assignee.assign(to_bind, bound_value)
-                    for parameter in update_parameters:
-                        if parameter not in target._parameter_table:
-                            target._parameter_table[parameter] = ParameterReferences(())
-                        target._parameter_table[parameter].add((operation, index))
-                    if not new_parameter.parameters:
-                        new_parameter = validate(new_parameter.numeric())
-                elif isinstance(assignee, QuantumCircuit):
-                    new_parameter = assignee.assign_parameters(
-                        {to_bind: bound_value}, inplace=False, flat_input=True
-                    )
-                else:
-                    raise RuntimeError(  # pragma: no cover
-                        f"Saw an unknown type during symbolic binding: {assignee}."
-                        " This may indicate an internal logic error in symbol tracking."
-                    )
-                if operation is ParameterTable.GLOBAL_PHASE:
-                    # We've already handled parameter table updates in bulk, so we need to skip the
-                    # public setter trying to do it again.
-                    target._global_phase = new_parameter
-                else:
-                    operation.params[index] = new_parameter
-
-        # After we've been through everything at the top level, make a single visit to each
-        # operation we've seen, rebinding its definition if necessary.
-        for operation in seen_operations.values():
-            if (
-                definition := getattr(operation, "_definition", None)
-            ) is not None and definition.num_parameters:
-                definition.assign_parameters(
-                    parameter_binds.mapping, inplace=True, flat_input=True, strict=False
-                )
+            parameter_binds = _ParameterBindsSequence(target._data.parameters, parameters)
+            target._data.assign_parameters_sequence(parameters)
 
         # Finally, assign the parameters inside any of the calibrations.  We don't track these in
         # the `ParameterTable`, so we manually reconstruct things.
@@ -4403,7 +4389,9 @@ class QuantumCircuit:
 
         if qargs:
             # This uses a `dict` not a `set` to guarantee a deterministic order to the arguments.
-            qubits = tuple({q: None for qarg in qargs for q in self.qbit_argument_conversion(qarg)})
+            qubits = tuple(
+                {q: None for qarg in qargs for q in self._qbit_argument_conversion(qarg)}
+            )
             return self.append(
                 CircuitInstruction(Barrier(len(qubits), label=label), qubits, ()), copy=False
             )
@@ -4450,9 +4438,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.h import HGate
-
-        return self.append(HGate(), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.HGate, [qubit], ())
 
     def ch(
         self,
@@ -4476,6 +4462,12 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CHGate, [control_qubit, target_qubit], (), label=label
+            )
+
         from .library.standard_gates.h import CHGate
 
         return self.append(
@@ -4496,9 +4488,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.i import IGate
-
-        return self.append(IGate(), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.IGate, [qubit], ())
 
     def ms(self, theta: ParameterValueType, qubits: Sequence[QubitSpecifier]) -> InstructionSet:
         """Apply :class:`~qiskit.circuit.library.MSGate`.
@@ -4529,9 +4519,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.p import PhaseGate
-
-        return self.append(PhaseGate(theta), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.PhaseGate, [qubit], (theta,))
 
     def cp(
         self,
@@ -4557,6 +4545,12 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CPhaseGate, [control_qubit, target_qubit], (theta,), label=label
+            )
+
         from .library.standard_gates.p import CPhaseGate
 
         return self.append(
@@ -4613,9 +4607,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.r import RGate
-
-        return self.append(RGate(theta, phi), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.RGate, [qubit], [theta, phi])
 
     def rv(
         self,
@@ -4662,10 +4654,8 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.x import RCCXGate
-
-        return self.append(
-            RCCXGate(), [control_qubit1, control_qubit2, target_qubit], [], copy=False
+        return self._append_standard_gate(
+            StandardGate.RCCXGate, [control_qubit1, control_qubit2, target_qubit], ()
         )
 
     def rcccx(
@@ -4688,13 +4678,10 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.x import RC3XGate
-
-        return self.append(
-            RC3XGate(),
+        return self._append_standard_gate(
+            StandardGate.RC3XGate,
             [control_qubit1, control_qubit2, control_qubit3, target_qubit],
-            [],
-            copy=False,
+            (),
         )
 
     def rx(
@@ -4712,9 +4699,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.rx import RXGate
-
-        return self.append(RXGate(theta, label=label), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.RXGate, [qubit], [theta], label=label)
 
     def crx(
         self,
@@ -4740,6 +4725,12 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CRXGate, [control_qubit, target_qubit], [theta], label=label
+            )
+
         from .library.standard_gates.rx import CRXGate
 
         return self.append(
@@ -4764,9 +4755,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.rxx import RXXGate
-
-        return self.append(RXXGate(theta), [qubit1, qubit2], [], copy=False)
+        return self._append_standard_gate(StandardGate.RXXGate, [qubit1, qubit2], [theta])
 
     def ry(
         self, theta: ParameterValueType, qubit: QubitSpecifier, label: str | None = None
@@ -4783,9 +4772,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.ry import RYGate
-
-        return self.append(RYGate(theta, label=label), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.RYGate, [qubit], [theta], label=label)
 
     def cry(
         self,
@@ -4811,6 +4798,12 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CRYGate, [control_qubit, target_qubit], [theta], label=label
+            )
+
         from .library.standard_gates.ry import CRYGate
 
         return self.append(
@@ -4835,9 +4828,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.ryy import RYYGate
-
-        return self.append(RYYGate(theta), [qubit1, qubit2], [], copy=False)
+        return self._append_standard_gate(StandardGate.RYYGate, [qubit1, qubit2], [theta])
 
     def rz(self, phi: ParameterValueType, qubit: QubitSpecifier) -> InstructionSet:
         """Apply :class:`~qiskit.circuit.library.RZGate`.
@@ -4851,9 +4842,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.rz import RZGate
-
-        return self.append(RZGate(phi), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.RZGate, [qubit], [phi])
 
     def crz(
         self,
@@ -4879,6 +4868,12 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CRZGate, [control_qubit, target_qubit], [theta], label=label
+            )
+
         from .library.standard_gates.rz import CRZGate
 
         return self.append(
@@ -4903,9 +4898,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.rzx import RZXGate
-
-        return self.append(RZXGate(theta), [qubit1, qubit2], [], copy=False)
+        return self._append_standard_gate(StandardGate.RZXGate, [qubit1, qubit2], [theta])
 
     def rzz(
         self, theta: ParameterValueType, qubit1: QubitSpecifier, qubit2: QubitSpecifier
@@ -4922,9 +4915,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.rzz import RZZGate
-
-        return self.append(RZZGate(theta), [qubit1, qubit2], [], copy=False)
+        return self._append_standard_gate(StandardGate.RZZGate, [qubit1, qubit2], [theta])
 
     def ecr(self, qubit1: QubitSpecifier, qubit2: QubitSpecifier) -> InstructionSet:
         """Apply :class:`~qiskit.circuit.library.ECRGate`.
@@ -4937,9 +4928,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.ecr import ECRGate
-
-        return self.append(ECRGate(), [qubit1, qubit2], [], copy=False)
+        return self._append_standard_gate(StandardGate.ECRGate, [qubit1, qubit2], ())
 
     def s(self, qubit: QubitSpecifier) -> InstructionSet:
         """Apply :class:`~qiskit.circuit.library.SGate`.
@@ -4952,9 +4941,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.s import SGate
-
-        return self.append(SGate(), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.SGate, [qubit], ())
 
     def sdg(self, qubit: QubitSpecifier) -> InstructionSet:
         """Apply :class:`~qiskit.circuit.library.SdgGate`.
@@ -4967,9 +4954,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.s import SdgGate
-
-        return self.append(SdgGate(), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.SdgGate, [qubit], ())
 
     def cs(
         self,
@@ -4993,6 +4978,12 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CSGate, [control_qubit, target_qubit], (), label=label
+            )
+
         from .library.standard_gates.s import CSGate
 
         return self.append(
@@ -5024,6 +5015,12 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CSdgGate, [control_qubit, target_qubit], (), label=label
+            )
+
         from .library.standard_gates.s import CSdgGate
 
         return self.append(
@@ -5044,9 +5041,11 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.swap import SwapGate
-
-        return self.append(SwapGate(), [qubit1, qubit2], [], copy=False)
+        return self._append_standard_gate(
+            StandardGate.SwapGate,
+            [qubit1, qubit2],
+            (),
+        )
 
     def iswap(self, qubit1: QubitSpecifier, qubit2: QubitSpecifier) -> InstructionSet:
         """Apply :class:`~qiskit.circuit.library.iSwapGate`.
@@ -5059,9 +5058,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.iswap import iSwapGate
-
-        return self.append(iSwapGate(), [qubit1, qubit2], [], copy=False)
+        return self._append_standard_gate(StandardGate.ISwapGate, [qubit1, qubit2], ())
 
     def cswap(
         self,
@@ -5087,6 +5084,15 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CSwapGate,
+                [control_qubit, target_qubit1, target_qubit2],
+                (),
+                label=label,
+            )
+
         from .library.standard_gates.swap import CSwapGate
 
         return self.append(
@@ -5107,9 +5113,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.sx import SXGate
-
-        return self.append(SXGate(), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.SXGate, [qubit], ())
 
     def sxdg(self, qubit: QubitSpecifier) -> InstructionSet:
         """Apply :class:`~qiskit.circuit.library.SXdgGate`.
@@ -5122,9 +5126,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.sx import SXdgGate
-
-        return self.append(SXdgGate(), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.SXdgGate, [qubit], ())
 
     def csx(
         self,
@@ -5148,6 +5150,12 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CSXGate, [control_qubit, target_qubit], (), label=label
+            )
+
         from .library.standard_gates.sx import CSXGate
 
         return self.append(
@@ -5168,9 +5176,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.t import TGate
-
-        return self.append(TGate(), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.TGate, [qubit], ())
 
     def tdg(self, qubit: QubitSpecifier) -> InstructionSet:
         """Apply :class:`~qiskit.circuit.library.TdgGate`.
@@ -5183,9 +5189,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.t import TdgGate
-
-        return self.append(TdgGate(), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.TdgGate, [qubit], ())
 
     def u(
         self,
@@ -5207,9 +5211,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.u import UGate
-
-        return self.append(UGate(theta, phi, lam), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.UGate, [qubit], [theta, phi, lam])
 
     def cu(
         self,
@@ -5241,6 +5243,15 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CUGate,
+                [control_qubit, target_qubit],
+                [theta, phi, lam, gamma],
+                label=label,
+            )
+
         from .library.standard_gates.u import CUGate
 
         return self.append(
@@ -5262,9 +5273,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.x import XGate
-
-        return self.append(XGate(label=label), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.XGate, [qubit], (), label=label)
 
     def cx(
         self,
@@ -5288,6 +5297,14 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CXGate,
+                [control_qubit, target_qubit],
+                (),
+                label=label,
+            )
 
         from .library.standard_gates.x import CXGate
 
@@ -5310,9 +5327,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.dcx import DCXGate
-
-        return self.append(DCXGate(), [qubit1, qubit2], [], copy=False)
+        return self._append_standard_gate(StandardGate.DCXGate, [qubit1, qubit2], ())
 
     def ccx(
         self,
@@ -5336,6 +5351,14 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |11> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["11", 3]:
+            return self._append_standard_gate(
+                StandardGate.CCXGate,
+                [control_qubit1, control_qubit2, target_qubit],
+                (),
+            )
+
         from .library.standard_gates.x import CCXGate
 
         return self.append(
@@ -5381,12 +5404,12 @@ class QuantumCircuit:
             ValueError: if the given mode is not known, or if too few ancilla qubits are passed.
             AttributeError: if no ancilla qubits are passed, but some are needed.
         """
-        from .library.standard_gates.x import MCXGrayCode, MCXRecursive, MCXVChain
+        from .library.standard_gates.x import MCXGate, MCXRecursive, MCXVChain
 
         num_ctrl_qubits = len(control_qubits)
 
         available_implementations = {
-            "noancilla": MCXGrayCode(num_ctrl_qubits, ctrl_state=ctrl_state),
+            "noancilla": MCXGate(num_ctrl_qubits, ctrl_state=ctrl_state),
             "recursion": MCXRecursive(num_ctrl_qubits, ctrl_state=ctrl_state),
             "v-chain": MCXVChain(num_ctrl_qubits, False, ctrl_state=ctrl_state),
             "v-chain-dirty": MCXVChain(num_ctrl_qubits, dirty_ancillas=True, ctrl_state=ctrl_state),
@@ -5400,7 +5423,7 @@ class QuantumCircuit:
 
         # check ancilla input
         if ancilla_qubits:
-            _ = self.qbit_argument_conversion(ancilla_qubits)
+            _ = self._qbit_argument_conversion(ancilla_qubits)
 
         try:
             gate = available_implementations[mode]
@@ -5440,9 +5463,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.y import YGate
-
-        return self.append(YGate(), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.YGate, [qubit], ())
 
     def cy(
         self,
@@ -5466,6 +5487,15 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CYGate,
+                [control_qubit, target_qubit],
+                (),
+                label=label,
+            )
+
         from .library.standard_gates.y import CYGate
 
         return self.append(
@@ -5486,9 +5516,7 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
-        from .library.standard_gates.z import ZGate
-
-        return self.append(ZGate(), [qubit], [], copy=False)
+        return self._append_standard_gate(StandardGate.ZGate, [qubit], ())
 
     def cz(
         self,
@@ -5512,6 +5540,12 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |1> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["1", 1]:
+            return self._append_standard_gate(
+                StandardGate.CZGate, [control_qubit, target_qubit], (), label=label
+            )
+
         from .library.standard_gates.z import CZGate
 
         return self.append(
@@ -5545,6 +5579,15 @@ class QuantumCircuit:
         Returns:
             A handle to the instructions created.
         """
+        # if the control state is |11> use the fast Rust version of the gate
+        if ctrl_state is None or ctrl_state in ["11", 3]:
+            return self._append_standard_gate(
+                StandardGate.CCZGate,
+                [control_qubit1, control_qubit2, target_qubit],
+                (),
+                label=label,
+            )
+
         from .library.standard_gates.z import CCZGate
 
         return self.append(
@@ -5706,7 +5749,7 @@ class QuantumCircuit:
                 * Statevector or vector of complex amplitudes to initialize to.
                 * Labels of basis states of the Pauli eigenstates Z, X, Y. See
                   :meth:`.Statevector.from_label`. Notice the order of the labels is reversed with
-                  respect to the qubit index to be applied to. Example label '01' initializes the
+                  respect to the qubit index to be applied to. Example label ``'01'`` initializes the
                   qubit zero to :math:`|1\rangle` and the qubit one to :math:`|0\rangle`.
                 * An integer that is used as a bitmap indicating which qubits to initialize to
                   :math:`|1\rangle`. Example: setting params to 5 would initialize qubit 0 and qubit
@@ -5880,7 +5923,7 @@ class QuantumCircuit:
         """Finish a scope used in the control-flow builder interface, and return it to the caller.
 
         This should only be done by the control-flow context managers, since they naturally
-        synchronise the creation and deletion of stack elements."""
+        synchronize the creation and deletion of stack elements."""
         return self._control_flow_scopes.pop()
 
     def _peek_previous_instruction_in_scope(self) -> CircuitInstruction:
@@ -5907,36 +5950,8 @@ class QuantumCircuit:
         if not self._data:
             raise CircuitError("This circuit contains no instructions.")
         instruction = self._data.pop()
-        if isinstance(instruction.operation, Instruction):
-            self._update_parameter_table_on_instruction_removal(instruction)
         return instruction
 
-    def _update_parameter_table_on_instruction_removal(self, instruction: CircuitInstruction):
-        """Update the :obj:`.ParameterTable` of this circuit given that an instance of the given
-        ``instruction`` has just been removed from the circuit.
-
-        .. note::
-
-            This does not account for the possibility for the same instruction instance being added
-            more than once to the circuit.  At the time of writing (2021-11-17, main commit 271a82f)
-            there is a defensive ``deepcopy`` of parameterised instructions inside
-            :meth:`.QuantumCircuit.append`, so this should be safe.  Trying to account for it would
-            involve adding a potentially quadratic-scaling loop to check each entry in ``data``.
-        """
-        atomic_parameters: list[tuple[Parameter, int]] = []
-        for index, parameter in enumerate(instruction.operation.params):
-            if isinstance(parameter, (ParameterExpression, QuantumCircuit)):
-                atomic_parameters.extend((p, index) for p in parameter.parameters)
-        for atomic_parameter, index in atomic_parameters:
-            new_entries = self._parameter_table[atomic_parameter].copy()
-            new_entries.discard((instruction.operation, index))
-            if not new_entries:
-                del self._parameter_table[atomic_parameter]
-                # Invalidate cache.
-                self._parameters = None
-            else:
-                self._parameter_table[atomic_parameter] = new_entries
-
     @typing.overload
     def while_loop(
         self,
@@ -6582,13 +6597,14 @@ class _OuterCircuitScopeInterface(CircuitScopeInterface):
     def instructions(self):
         return self.circuit._data
 
-    def append(self, instruction):
+    def append(self, instruction, *, _standard_gate: bool = False):
         # QuantumCircuit._append is semi-public, so we just call back to it.
-        return self.circuit._append(instruction)
+        return self.circuit._append(instruction, _standard_gate=_standard_gate)
 
     def extend(self, data: CircuitData):
         self.circuit._data.extend(data)
-        data.foreach_op(self.circuit._track_operation)
+        self.circuit.duration = None
+        self.circuit.unit = "dt"
 
     def resolve_classical_resource(self, specifier):
         # This is slightly different to cbit_argument_conversion, because it should not
@@ -6745,11 +6761,3 @@ def _bit_argument_conversion_scalar(specifier, bit_sequence, bit_set, type_):
         else f"Invalid bit index: '{specifier}' of type '{type(specifier)}'"
     )
     raise CircuitError(message)
-
-
-def _normalize_global_phase(angle):
-    """Return the normalized form of an angle for use in the global phase.  This coerces to float if
-    possible, and fixes to the interval :math:`[0, 2\\pi)`."""
-    if isinstance(angle, ParameterExpression) and angle.parameters:
-        return angle
-    return float(angle) % (2.0 * np.pi)