Merge branch 'main' into oxidize-commutative-analysis

Cargo.toml

@@ -15,7 +15,7 @@ license = "Apache-2.0"
 # Each crate can add on specific features freely as it inherits.
 [workspace.dependencies]
 bytemuck = "1.17"
-indexmap.version = "2.4.0"
+indexmap.version = "2.5.0"
 hashbrown.version = "0.14.5"
 num-bigint = "0.4"
 num-complex = "0.4"

crates/circuit/src/circuit_data.rs

@@ -31,6 +31,7 @@ use pyo3::types::{IntoPyDict, PyDict, PyList, PySet, PyTuple, PyType};
 use pyo3::{import_exception, intern, PyTraverseError, PyVisit};
 
 use hashbrown::{HashMap, HashSet};
+use indexmap::IndexMap;
 use smallvec::SmallVec;
 
 import_exception!(qiskit.circuit.exceptions, CircuitError);
@@ -983,6 +984,22 @@ impl CircuitData {
         self.param_table.clear();
     }
 
+    /// Counts the number of times each operation is used in the circuit.
+    ///
+    /// # Parameters
+    /// - `self` - A mutable reference to the CircuitData struct.
+    ///
+    /// # Returns
+    /// An IndexMap containing the operation names as keys and their respective counts as values.
+    pub fn count_ops(&self) -> IndexMap<&str, usize, ::ahash::RandomState> {
+        let mut ops_count: IndexMap<&str, usize, ::ahash::RandomState> = IndexMap::default();
+        for instruction in &self.data {
+            *ops_count.entry(instruction.op.name()).or_insert(0) += 1;
+        }
+        ops_count.par_sort_by(|_k1, v1, _k2, v2| v2.cmp(v1));
+        ops_count
+    }
+
     // Marks this pyclass as NOT hashable.
     #[classattr]
     const __hash__: Option<Py<PyAny>> = None;

qiskit/circuit/quantumcircuit.py

@@ -3516,10 +3516,8 @@ def count_ops(self) -> "OrderedDict[Instruction, int]":
         Returns:
             OrderedDict: a breakdown of how many operations of each kind, sorted by amount.
         """
-        count_ops: dict[Instruction, int] = {}
-        for instruction in self._data:
-            count_ops[instruction.operation.name] = count_ops.get(instruction.operation.name, 0) + 1
-        return OrderedDict(sorted(count_ops.items(), key=lambda kv: kv[1], reverse=True))
+        ops_dict = self._data.count_ops()
+        return OrderedDict(ops_dict)
 
     def num_nonlocal_gates(self) -> int:
         """Return number of non-local gates (i.e. involving 2+ qubits).

qiskit/transpiler/passes/optimization/split_2q_unitaries.py

@@ -51,7 +51,7 @@ def run(self, dag: DAGCircuit):
             ):
                 continue
 
-            decomp = TwoQubitWeylDecomposition(node.op, fidelity=self.requested_fidelity)
+            decomp = TwoQubitWeylDecomposition(node.matrix, fidelity=self.requested_fidelity)
             if (
                 decomp._inner_decomposition.specialization
                 == TwoQubitWeylDecomposition._specializations.IdEquiv

releasenotes/notes/fix-split-2q-unitaries-custom-gate-d10f7670a35548f4.yaml

@@ -0,0 +1,6 @@
+---
+fixes:
+  - |
+    Fixed a bug in :class:`.Split2QUnitaries` where it would fail to run on circuits
+    with custom gates that didn't implement :meth:`__array__`.
+    See `#12984 <https://github.com/Qiskit/qiskit/issues/12970>`__.

releasenotes/notes/port-countops-method-3ad362c20b13182c.yaml

@@ -0,0 +1,5 @@
+---
+features_circuits:
+  - |
+    The :meth:`~.QuantumCircuit.count_ops` method in :class:`.QuantumCircuit` 
+    has been re-written in Rust. It now runs between 3 and 9 times faster.

test/python/transpiler/test_split_2q_unitaries.py

@@ -19,7 +19,7 @@
 
 from qiskit import QuantumCircuit, QuantumRegister, transpile
 from qiskit.circuit.library import UnitaryGate, XGate, ZGate, HGate
-from qiskit.circuit import Parameter, CircuitInstruction
+from qiskit.circuit import Parameter, CircuitInstruction, Gate
 from qiskit.providers.fake_provider import GenericBackendV2
 from qiskit.quantum_info import Operator
 from qiskit.transpiler import PassManager
@@ -223,3 +223,40 @@ def test_split_qft(self):
         pm.append(Split2QUnitaries())
         qc_split = pm.run(qc)
         self.assertEqual(26, qc_split.num_nonlocal_gates())
+
+    def test_gate_no_array(self):
+        """
+        Test that the pass doesn't fail when the circuit contains a custom gate
+        with no ``__array__`` implementation.
+
+        Reproduce from: https://github.com/Qiskit/qiskit/issues/12970
+        """
+
+        class MyGate(Gate):
+            """Custom gate"""
+
+            def __init__(self):
+                super().__init__("mygate", 2, [])
+
+            def to_matrix(self):
+                return np.eye(4, dtype=complex)
+                # return np.eye(4, dtype=float)
+
+        def mygate(self, qubit1, qubit2):
+            return self.append(MyGate(), [qubit1, qubit2], [])
+
+        QuantumCircuit.mygate = mygate
+
+        qc = QuantumCircuit(2)
+        qc.mygate(0, 1)
+
+        pm = PassManager()
+        pm.append(Collect2qBlocks())
+        pm.append(ConsolidateBlocks())
+        pm.append(Split2QUnitaries())
+        qc_split = pm.run(qc)
+
+        self.assertTrue(Operator(qc).equiv(qc_split))
+        self.assertTrue(
+            matrix_equal(Operator(qc).data, Operator(qc_split).data, ignore_phase=False)
+        )