qiskit 1.2.0__tar.gz → 1.2.1__tar.gz

{qiskit-1.2.0 → qiskit-1.2.1}/Cargo.lock

@@ -1161,7 +1161,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-accelerate"
-version = "1.2.0"
+version = "1.2.1"
 dependencies = [
  "ahash 0.8.11",
  "approx",
@@ -1189,7 +1189,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-circuit"
-version = "1.2.0"
+version = "1.2.1"
 dependencies = [
  "bytemuck",
  "hashbrown 0.14.5",
@@ -1203,7 +1203,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-pyext"
-version = "1.2.0"
+version = "1.2.1"
 dependencies = [
  "pyo3",
  "qiskit-accelerate",
@@ -1214,7 +1214,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm2"
-version = "1.2.0"
+version = "1.2.1"
 dependencies = [
  "hashbrown 0.14.5",
  "num-bigint",
@@ -1224,7 +1224,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm3"
-version = "1.2.0"
+version = "1.2.1"
 dependencies = [
  "hashbrown 0.14.5",
  "indexmap",

{qiskit-1.2.0 → qiskit-1.2.1}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "1.2.0"
+version = "1.2.1"
 edition = "2021"
 rust-version = "1.70"  # Keep in sync with README.md and rust-toolchain.toml.
 license = "Apache-2.0"

{qiskit-1.2.0 → qiskit-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qiskit
-Version: 1.2.0
+Version: 1.2.1
 Summary: An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.
 Author-email: Qiskit Development Team <qiskit@us.ibm.com>
 License: Apache 2.0

{qiskit-1.2.0 → qiskit-1.2.1}/crates/accelerate/src/sabre/layer.rs

@@ -70,7 +70,10 @@ impl FrontLayer {
     pub fn remove(&mut self, index: &NodeIndex) {
         // The actual order in the indexmap doesn't matter as long as it's reproducible.
         // Swap-remove is more efficient than a full shift-remove.
-        let [a, b] = self.nodes.swap_remove(index).unwrap();
+        let [a, b] = self
+            .nodes
+            .swap_remove(index)
+            .expect("Tried removing index that does not exist.");
         self.qubits[a.index()] = None;
         self.qubits[b.index()] = None;
     }

{qiskit-1.2.0 → qiskit-1.2.1}/crates/accelerate/src/sabre/route.rs

@@ -27,6 +27,7 @@ use rustworkx_core::petgraph::prelude::*;
 use rustworkx_core::petgraph::visit::EdgeRef;
 use rustworkx_core::shortest_path::dijkstra;
 use rustworkx_core::token_swapper::token_swapper;
+use smallvec::{smallvec, SmallVec};
 
 use crate::getenv_use_multiple_threads;
 use crate::nlayout::{NLayout, PhysicalQubit};
@@ -286,7 +287,7 @@ impl<'a, 'b> RoutingState<'a, 'b> {
     fn force_enable_closest_node(
         &mut self,
         current_swaps: &mut Vec<[PhysicalQubit; 2]>,
-    ) -> NodeIndex {
+    ) -> SmallVec<[NodeIndex; 2]> {
         let (&closest_node, &qubits) = {
             let dist = &self.target.distance;
             self.front_layer
@@ -328,7 +329,32 @@ impl<'a, 'b> RoutingState<'a, 'b> {
             current_swaps.push([shortest_path[end], shortest_path[end - 1]]);
         }
         current_swaps.iter().for_each(|&swap| self.apply_swap(swap));
-        closest_node
+
+        // If we apply a single swap it could be that we route 2 nodes; that is a setup like
+        //  A - B - A - B
+        // and we swap the middle two qubits. This cannot happen if we apply 2 or more swaps.
+        if current_swaps.len() > 1 {
+            smallvec![closest_node]
+        } else {
+            // check if the closest node has neighbors that are now routable -- for that we get
+            // the other physical qubit that was swapped and check whether the node on it
+            // is now routable
+            let mut possible_other_qubit = current_swaps[0]
+                .iter()
+                // check if other nodes are in the front layer that are connected by this swap
+                .filter_map(|&swap_qubit| self.front_layer.qubits()[swap_qubit.index()])
+                // remove the closest_node, which we know we already routed
+                .filter(|(node_index, _other_qubit)| *node_index != closest_node)
+                .map(|(_node_index, other_qubit)| other_qubit);
+
+            // if there is indeed another candidate, check if that gate is routable
+            if let Some(other_qubit) = possible_other_qubit.next() {
+                if let Some(also_routed) = self.routable_node_on_qubit(other_qubit) {
+                    return smallvec![closest_node, also_routed];
+                }
+            }
+            smallvec![closest_node]
+        }
     }
 
     /// Return the swap of two virtual qubits that produces the best score of all possible swaps.
@@ -573,14 +599,14 @@ pub fn swap_map_trial(
         }
         if routable_nodes.is_empty() {
             // If we exceeded the max number of heuristic-chosen swaps without making progress,
-            // unwind to the last progress point and greedily swap to bring a ndoe together.
+            // unwind to the last progress point and greedily swap to bring a node together.
             // Efficiency doesn't matter much; this path never gets taken unless we're unlucky.
             current_swaps
                 .drain(..)
                 .rev()
                 .for_each(|swap| state.apply_swap(swap));
             let force_routed = state.force_enable_closest_node(&mut current_swaps);
-            routable_nodes.push(force_routed);
+            routable_nodes.extend(force_routed);
         }
         state.update_route(&routable_nodes, current_swaps);
         if state.heuristic.decay.is_some() {

{qiskit-1.2.0 → qiskit-1.2.1}/crates/accelerate/src/two_qubit_decompose.rs

@@ -55,6 +55,7 @@ use qiskit_circuit::circuit_data::CircuitData;
 use qiskit_circuit::circuit_instruction::OperationFromPython;
 use qiskit_circuit::gate_matrix::{CX_GATE, H_GATE, ONE_QUBIT_IDENTITY, SX_GATE, X_GATE};
 use qiskit_circuit::operations::{Param, StandardGate};
+use qiskit_circuit::packed_instruction::PackedOperation;
 use qiskit_circuit::slice::{PySequenceIndex, SequenceIndex};
 use qiskit_circuit::util::{c64, GateArray1Q, GateArray2Q, C_M_ONE, C_ONE, C_ZERO, IM, M_IM};
 use qiskit_circuit::Qubit;
@@ -2071,26 +2072,51 @@ impl TwoQubitBasisDecomposer {
     ) -> PyResult<CircuitData> {
         let kak_gate = kak_gate.extract::<OperationFromPython>(py)?;
         let sequence = self.__call__(unitary, basis_fidelity, approximate, _num_basis_uses)?;
-        CircuitData::from_standard_gates(
-            py,
-            2,
-            sequence
-                .gates
-                .into_iter()
-                .map(|(gate, params, qubits)| match gate {
-                    Some(gate) => (
-                        gate,
-                        params.into_iter().map(Param::Float).collect(),
-                        qubits.into_iter().map(|x| Qubit(x.into())).collect(),
-                    ),
-                    None => (
-                        kak_gate.operation.standard_gate(),
-                        kak_gate.params.clone(),
-                        qubits.into_iter().map(|x| Qubit(x.into())).collect(),
-                    ),
-                }),
-            Param::Float(sequence.global_phase),
-        )
+        match kak_gate.operation.try_standard_gate() {
+            Some(std_kak_gate) => CircuitData::from_standard_gates(
+                py,
+                2,
+                sequence
+                    .gates
+                    .into_iter()
+                    .map(|(gate, params, qubits)| match gate {
+                        Some(gate) => (
+                            gate,
+                            params.into_iter().map(Param::Float).collect(),
+                            qubits.into_iter().map(|x| Qubit(x.into())).collect(),
+                        ),
+                        None => (
+                            std_kak_gate,
+                            kak_gate.params.clone(),
+                            qubits.into_iter().map(|x| Qubit(x.into())).collect(),
+                        ),
+                    }),
+                Param::Float(sequence.global_phase),
+            ),
+            None => CircuitData::from_packed_operations(
+                py,
+                2,
+                0,
+                sequence
+                    .gates
+                    .into_iter()
+                    .map(|(gate, params, qubits)| match gate {
+                        Some(gate) => (
+                            PackedOperation::from_standard(gate),
+                            params.into_iter().map(Param::Float).collect(),
+                            qubits.into_iter().map(|x| Qubit(x.into())).collect(),
+                            Vec::new(),
+                        ),
+                        None => (
+                            kak_gate.operation.clone(),
+                            kak_gate.params.clone(),
+                            qubits.into_iter().map(|x| Qubit(x.into())).collect(),
+                            Vec::new(),
+                        ),
+                    }),
+                Param::Float(sequence.global_phase),
+            ),
+        }
     }
 
     fn num_basis_gates(&self, unitary: PyReadonlyArray2<Complex64>) -> usize {

{qiskit-1.2.0 → qiskit-1.2.1}/crates/circuit/src/circuit_data.rs

@@ -15,10 +15,10 @@ use std::cell::RefCell;
 
 use crate::bit_data::BitData;
 use crate::circuit_instruction::{CircuitInstruction, OperationFromPython};
-use crate::imports::{ANNOTATED_OPERATION, QUANTUM_CIRCUIT, QUBIT};
+use crate::imports::{ANNOTATED_OPERATION, CLBIT, QUANTUM_CIRCUIT, QUBIT};
 use crate::interner::{IndexedInterner, Interner, InternerKey};
 use crate::operations::{Operation, OperationRef, Param, StandardGate};
-use crate::packed_instruction::PackedInstruction;
+use crate::packed_instruction::{PackedInstruction, PackedOperation};
 use crate::parameter_table::{ParameterTable, ParameterTableError, ParameterUse, ParameterUuid};
 use crate::slice::{PySequenceIndex, SequenceIndex};
 use crate::{Clbit, Qubit};
@@ -104,6 +104,71 @@ pub struct CircuitData {
 }
 
 impl CircuitData {
+    /// An alternate constructor to build a new `CircuitData` from an iterator
+    /// of packed operations. This can be used to build a circuit from a sequence
+    /// of `PackedOperation` without needing to involve Python.
+    ///
+    /// This can be connected with the Python space
+    /// QuantumCircuit.from_circuit_data() constructor to build a full
+    /// QuantumCircuit from Rust.
+    ///
+    /// # Arguments
+    ///
+    /// * py: A GIL handle this is needed to instantiate Qubits in Python space
+    /// * num_qubits: The number of qubits in the circuit. These will be created
+    ///     in Python as loose bits without a register.
+    /// * num_clbits: The number of classical bits in the circuit. These will be created
+    ///     in Python as loose bits without a register.
+    /// * instructions: An iterator of the (packed operation, params, qubits, clbits) to
+    ///     add to the circuit
+    /// * global_phase: The global phase to use for the circuit
+    pub fn from_packed_operations<I>(
+        py: Python,
+        num_qubits: u32,
+        num_clbits: u32,
+        instructions: I,
+        global_phase: Param,
+    ) -> PyResult<Self>
+    where
+        I: IntoIterator<
+            Item = (
+                PackedOperation,
+                SmallVec<[Param; 3]>,
+                Vec<Qubit>,
+                Vec<Clbit>,
+            ),
+        >,
+    {
+        let instruction_iter = instructions.into_iter();
+        let mut res = Self::with_capacity(
+            py,
+            num_qubits,
+            num_clbits,
+            instruction_iter.size_hint().0,
+            global_phase,
+        )?;
+        for (operation, params, qargs, cargs) in instruction_iter {
+            let qubits = (&mut res.qargs_interner)
+                .intern(InternerKey::Value(qargs))?
+                .index;
+            let clbits = (&mut res.cargs_interner)
+                .intern(InternerKey::Value(cargs))?
+                .index;
+            let params = (!params.is_empty()).then(|| Box::new(params));
+            res.data.push(PackedInstruction {
+                op: operation,
+                qubits,
+                clbits,
+                params,
+                extra_attrs: None,
+                #[cfg(feature = "cache_pygates")]
+                py_op: RefCell::new(None),
+            });
+            res.track_instruction_parameters(py, res.data.len() - 1)?;
+        }
+        Ok(res)
+    }
+
     /// An alternate constructor to build a new `CircuitData` from an iterator
     /// of standard gates. This can be used to build a circuit from a sequence
     /// of standard gates, such as for a `StandardGate` definition or circuit
@@ -169,6 +234,40 @@ impl CircuitData {
         Ok(res)
     }
 
+    /// Build an empty CircuitData object with an initially allocated instruction capacity
+    pub fn with_capacity(
+        py: Python,
+        num_qubits: u32,
+        num_clbits: u32,
+        instruction_capacity: usize,
+        global_phase: Param,
+    ) -> PyResult<Self> {
+        let mut res = CircuitData {
+            data: Vec::with_capacity(instruction_capacity),
+            qargs_interner: IndexedInterner::new(),
+            cargs_interner: IndexedInterner::new(),
+            qubits: BitData::new(py, "qubits".to_string()),
+            clbits: BitData::new(py, "clbits".to_string()),
+            param_table: ParameterTable::new(),
+            global_phase,
+        };
+        if num_qubits > 0 {
+            let qubit_cls = QUBIT.get_bound(py);
+            for _i in 0..num_qubits {
+                let bit = qubit_cls.call0()?;
+                res.add_qubit(py, &bit, true)?;
+            }
+        }
+        if num_clbits > 0 {
+            let clbit_cls = CLBIT.get_bound(py);
+            for _i in 0..num_clbits {
+                let bit = clbit_cls.call0()?;
+                res.add_clbit(py, &bit, true)?;
+            }
+        }
+        Ok(res)
+    }
+
     /// Add the entries from the `PackedInstruction` at the given index to the internal parameter
     /// table.
     fn track_instruction_parameters(

{qiskit-1.2.0 → qiskit-1.2.1}/crates/circuit/src/circuit_instruction.rs

@@ -547,12 +547,18 @@ impl<'py> FromPyObject<'py> for OperationFromPython {
             // mapping to avoid an `isinstance` check on `ControlledGate` - a standard gate has
             // nonzero `num_ctrl_qubits` iff it is a `ControlledGate`.
             //
-            // `ControlledGate` also has a `base_gate` attribute, and we don't track enough in Rust
-            // space to handle the case that that was mutated away from a standard gate.
+            // `ControlledGate` also has a `base_gate` attribute related to its historical
+            // implementation, which technically allows mutations from Python space.  The only
+            // mutation of a standard gate's `base_gate` that wouldn't have already broken the
+            // Python-space data model is setting a label, so we just catch that case and default
+            // back to non-standard-gate handling in that case.
             if standard.num_ctrl_qubits() != 0
                 && ((ob.getattr(intern!(py, "ctrl_state"))?.extract::<usize>()?
                     != (1 << standard.num_ctrl_qubits()) - 1)
-                    || ob.getattr(intern!(py, "mutable"))?.extract()?)
+                    || !ob
+                        .getattr(intern!(py, "base_gate"))?
+                        .getattr(intern!(py, "label"))?
+                        .is_none())
             {
                 break 'standard;
             }

{qiskit-1.2.0 → qiskit-1.2.1}/crates/circuit/src/gate_matrix.rs

@@ -387,12 +387,12 @@ pub fn cu_gate(theta: f64, phi: f64, lam: f64, gamma: f64) -> GateArray2Q {
             C_ZERO,
             c64(0., gamma).exp() * cos_theta,
             C_ZERO,
-            c64(0., gamma + phi).exp() * (-1.) * sin_theta,
+            c64(0., gamma + lam).exp() * (-1.) * sin_theta,
         ],
         [C_ZERO, C_ZERO, C_ONE, C_ZERO],
         [
             C_ZERO,
-            c64(0., gamma + lam).exp() * sin_theta,
+            c64(0., gamma + phi).exp() * sin_theta,
             C_ZERO,
             c64(0., gamma + phi + lam).exp() * cos_theta,
         ],

qiskit-1.2.1/qiskit/VERSION.txt

@@ -0,0 +1 @@
+1.2.1

{qiskit-1.2.0 → qiskit-1.2.1}/qiskit/circuit/__init__.py

@@ -580,6 +580,16 @@ The :class:`Store` instruction is particularly special, in that it allows writin
 :class:`Qubit` nor :class:`Clbit` operands, but has an explicit :attr:`~Store.lvalue` and
 :attr:`~Store.rvalue`.
 
+For example, to determine the parity of a bitstring ``cr`` and store it in another register ``creg``,
+the :class:`Store` instruction can be used in the following way::
+
+    parity = expr.lift(cr[0])
+    for i in range(1,n):
+        parity = expr.bit_xor(cr[i], parity)
+    qc.store(creg[0], parity)
+
+
+
 .. autoclass:: Store
     :show-inheritance:
     :members:

{qiskit-1.2.0 → qiskit-1.2.1}/qiskit/circuit/library/basis_change/qft.py

@@ -315,8 +315,10 @@ class QFTGate(Gate):
         """
         super().__init__(name="qft", num_qubits=num_qubits, params=[])
 
-    def __array__(self, dtype=complex):
+    def __array__(self, dtype=complex, copy=None):
         """Return a numpy array for the QFTGate."""
+        if copy is False:
+            raise ValueError("unable to avoid copy while creating an array as requested")
         n = self.num_qubits
         nums = np.arange(2**n)
         outer = np.outer(nums, nums)

{qiskit-1.2.0 → qiskit-1.2.1}/qiskit/circuit/library/data_preparation/initializer.py

@@ -21,6 +21,7 @@ import typing
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.instruction import Instruction
+from qiskit.circuit.library.generalized_gates import Isometry
 from .state_preparation import StatePreparation
 
 if typing.TYPE_CHECKING:
@@ -86,9 +87,11 @@ class Initialize(Instruction):
         """Call to create a circuit with gates that take the desired vector to zero.
 
         Returns:
-            Circuit to take ``self.params`` vector to :math:`|{00\\ldots0}\\rangle`
+            QuantumCircuit: circuit to take ``self.params`` vector to :math:`|{00\\ldots0}\\rangle`
         """
-        return self._stateprep._gates_to_uncompute()
+
+        isom = Isometry(self.params, 0, 0)
+        return isom._gates_to_uncompute()
 
     @property
     def params(self):

{qiskit-1.2.0 → qiskit-1.2.1}/qiskit/circuit/library/data_preparation/state_preparation.py

@@ -173,8 +173,8 @@ class StatePreparation(Gate):
         q = QuantumRegister(self.num_qubits, "q")
         initialize_circuit = QuantumCircuit(q, name="init_def")
 
-        isom = Isometry(self._params_arg, 0, 0)
-        initialize_circuit.append(isom, q[:])
+        isom = Isometry(self.params, 0, 0)
+        initialize_circuit.compose(isom.definition, copy=False, inplace=True)
 
         # invert the circuit to create the desired vector from zero (assuming
         # the qubits are in the zero state)

{qiskit-1.2.0 → qiskit-1.2.1}/qiskit/circuit/library/standard_gates/__init__.py

@@ -54,6 +54,13 @@ def get_standard_gate_name_mapping():
     from qiskit.circuit.delay import Delay
     from qiskit.circuit.reset import Reset
 
+    lambda_ = Parameter("λ")
+    theta = Parameter("ϴ")
+    phi = Parameter("φ")
+    gamma = Parameter("γ")
+    beta = Parameter("β")
+    time = Parameter("t")
+
     # Standard gates library mapping, multicontrolled gates not included since they're
     # variable width
     gates = [
@@ -61,38 +68,37 @@ def get_standard_gate_name_mapping():
         SXGate(),
         XGate(),
         CXGate(),
-        RZGate(Parameter("λ")),
-        RGate(Parameter("ϴ"), Parameter("φ")),
-        Reset(),
+        RZGate(lambda_),
+        RGate(theta, phi),
         C3SXGate(),
         CCXGate(),
         DCXGate(),
         CHGate(),
-        CPhaseGate(Parameter("ϴ")),
-        CRXGate(Parameter("ϴ")),
-        CRYGate(Parameter("ϴ")),
-        CRZGate(Parameter("ϴ")),
+        CPhaseGate(theta),
+        CRXGate(theta),
+        CRYGate(theta),
+        CRZGate(theta),
         CSwapGate(),
         CSXGate(),
-        CUGate(Parameter("ϴ"), Parameter("φ"), Parameter("λ"), Parameter("γ")),
-        CU1Gate(Parameter("λ")),
-        CU3Gate(Parameter("ϴ"), Parameter("φ"), Parameter("λ")),
+        CUGate(theta, phi, lambda_, gamma),
+        CU1Gate(lambda_),
+        CU3Gate(theta, phi, lambda_),
         CYGate(),
         CZGate(),
         CCZGate(),
-        GlobalPhaseGate(Parameter("ϴ")),
+        GlobalPhaseGate(theta),
         HGate(),
-        PhaseGate(Parameter("ϴ")),
+        PhaseGate(theta),
         RCCXGate(),
         RC3XGate(),
-        RXGate(Parameter("ϴ")),
-        RXXGate(Parameter("ϴ")),
-        RYGate(Parameter("ϴ")),
-        RYYGate(Parameter("ϴ")),
-        RZZGate(Parameter("ϴ")),
-        RZXGate(Parameter("ϴ")),
-        XXMinusYYGate(Parameter("ϴ"), Parameter("β")),
-        XXPlusYYGate(Parameter("ϴ"), Parameter("β")),
+        RXGate(theta),
+        RXXGate(theta),
+        RYGate(theta),
+        RYYGate(theta),
+        RZZGate(theta),
+        RZXGate(theta),
+        XXMinusYYGate(theta, beta),
+        XXPlusYYGate(theta, beta),
         ECRGate(),
         SGate(),
         SdgGate(),
@@ -103,13 +109,14 @@ def get_standard_gate_name_mapping():
         SXdgGate(),
         TGate(),
         TdgGate(),
-        UGate(Parameter("ϴ"), Parameter("φ"), Parameter("λ")),
-        U1Gate(Parameter("λ")),
-        U2Gate(Parameter("φ"), Parameter("λ")),
-        U3Gate(Parameter("ϴ"), Parameter("φ"), Parameter("λ")),
+        UGate(theta, phi, lambda_),
+        U1Gate(lambda_),
+        U2Gate(phi, lambda_),
+        U3Gate(theta, phi, lambda_),
         YGate(),
         ZGate(),
-        Delay(Parameter("t")),
+        Delay(time),
+        Reset(),
         Measure(),
     ]
     name_mapping = {gate.name: gate for gate in gates}

{qiskit-1.2.0 → qiskit-1.2.1}/qiskit/circuit/quantumcircuit.py

@@ -1152,17 +1152,41 @@ class QuantumCircuit:
         """The unit that :attr:`duration` is specified in."""
         self.metadata = {} if metadata is None else metadata
         """Arbitrary user-defined metadata for the circuit.
-
+ 
         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:
+    def _from_circuit_data(cls, data: CircuitData, add_regs: bool = False) -> typing.Self:
         """A private constructor from rust space circuit data."""
         out = QuantumCircuit()
+
+        if data.num_qubits > 0:
+            if add_regs:
+                qr = QuantumRegister(name="q", bits=data.qubits)
+                out.qregs = [qr]
+                out._qubit_indices = {
+                    bit: BitLocations(index, [(qr, index)]) for index, bit in enumerate(data.qubits)
+                }
+            else:
+                out._qubit_indices = {
+                    bit: BitLocations(index, []) for index, bit in enumerate(data.qubits)
+                }
+
+        if data.num_clbits > 0:
+            if add_regs:
+                cr = ClassicalRegister(name="c", bits=data.clbits)
+                out.cregs = [cr]
+                out._clbit_indices = {
+                    bit: BitLocations(index, [(cr, index)]) for index, bit in enumerate(data.clbits)
+                }
+            else:
+                out._clbit_indices = {
+                    bit: BitLocations(index, []) for index, bit in enumerate(data.clbits)
+                }
+
         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
@@ -3013,16 +3037,7 @@ class QuantumCircuit:
                         self._ancillas.append(bit)
 
             if isinstance(register, QuantumRegister):
-                self.qregs.append(register)
-
-                for idx, bit in enumerate(register):
-                    if bit in self._qubit_indices:
-                        self._qubit_indices[bit].registers.append((register, idx))
-                    else:
-                        self._data.add_qubit(bit)
-                        self._qubit_indices[bit] = BitLocations(
-                            self._data.num_qubits - 1, [(register, idx)]
-                        )
+                self._add_qreg(register)
 
             elif isinstance(register, ClassicalRegister):
                 self.cregs.append(register)
@@ -3041,6 +3056,16 @@ class QuantumCircuit:
             else:
                 raise CircuitError("expected a register")
 
+    def _add_qreg(self, qreg: QuantumRegister) -> None:
+        self.qregs.append(qreg)
+
+        for idx, bit in enumerate(qreg):
+            if bit in self._qubit_indices:
+                self._qubit_indices[bit].registers.append((qreg, idx))
+            else:
+                self._data.add_qubit(bit)
+                self._qubit_indices[bit] = BitLocations(self._data.num_qubits - 1, [(qreg, idx)])
+
     def add_bits(self, bits: Iterable[Bit]) -> None:
         """Add Bits to the circuit."""
         duplicate_bits = {

{qiskit-1.2.0 → qiskit-1.2.1}/qiskit/pulse/library/symbolic_pulses.py

@@ -1773,12 +1773,13 @@ def Square(
     is the sign function with the convention :math:`\\text{sign}\\left(0\\right)=1`.
 
     Args:
-        duration: Pulse length in terms of the sampling period `dt`.
-        amp: The magnitude of the amplitude of the square wave. Wave range is [-`amp`,`amp`].
+        duration: Pulse length in terms of the sampling period ``dt``.
+        amp: The magnitude of the amplitude of the square wave. Wave range is
+            :math:`\\left[-\\texttt{amp},\\texttt{amp}\\right]`.
         phase: The phase of the square wave (note that this is not equivalent to the angle of
             the complex amplitude).
         freq: The frequency of the square wave, in terms of 1 over sampling period.
-            If not provided defaults to a single cycle (i.e :math:'\\frac{1}{\\text{duration}}').
+            If not provided defaults to a single cycle (i.e :math:`\\frac{1}{\\text{duration}}`).
             The frequency is limited to the range :math:`\\left(0,0.5\\right]` (the Nyquist frequency).
         angle: The angle in radians of the complex phase factor uniformly
             scaling the pulse. Default value 0.