Use Rust generator function for QuantumVolume class

qiskit/circuit/library/quantum_volume.py

@@ -83,39 +83,48 @@ def __init__(
         depth = depth or num_qubits  # how many layers of SU(4)
         width = num_qubits // 2  # how many SU(4)s fit in each layer
         rng = seed if isinstance(seed, np.random.Generator) else np.random.default_rng(seed)
+        seed_name = seed
         if seed is None:
             # Get the internal entropy used to seed the default RNG, if no seed was given.  This
             # stays in the output name, so effectively stores a way of regenerating the circuit.
             # This is just best-effort only, for backwards compatibility, and isn't critical (if
             # someone needs full reproducibility, they should be manually controlling the seeding).
-            seed = getattr(getattr(rng.bit_generator, "seed_seq", None), "entropy", None)
+            seed_name = getattr(getattr(rng.bit_generator, "seed_seq", None), "entropy", None)
 
         super().__init__(
-            num_qubits, name="quantum_volume_" + str([num_qubits, depth, seed]).replace(" ", "")
+            num_qubits,
+            name="quantum_volume_" + str([num_qubits, depth, seed_name]).replace(" ", ""),
         )
-        base = self if flatten else QuantumCircuit(num_qubits, name=self.name)
-
-        # For each layer, generate a permutation of qubits
-        # Then generate and apply a Haar-random SU(4) to each pair
-        unitaries = scipy.stats.unitary_group.rvs(4, depth * width, rng).reshape(depth, width, 4, 4)
-        qubits = tuple(base.qubits)
-        for row in unitaries:
-            perm = rng.permutation(num_qubits)
-            if classical_permutation:
-                for w, unitary in enumerate(row):
-                    gate = UnitaryGate(unitary, check_input=False, num_qubits=2)
-                    qubit = 2 * w
-                    base._append(
-                        CircuitInstruction(gate, (qubits[perm[qubit]], qubits[perm[qubit + 1]]))
-                    )
+        if classical_permutation:
+            if seed is not None:
+                seed = rng.integers(0, dtype=np.int64)
+            qv_circ = quantum_volume(num_qubits, depth, seed)
+            qv_circ.name = self.name
+            if flatten:
+                self.compose(qv_circ, inplace=True)
             else:
+                self._append(CircuitInstruction(qv_circ.to_instruction(), tuple(self.qubits)))
+        else:
+            if seed is None:
+                seed = seed_name
+
+            base = self if flatten else QuantumCircuit(num_qubits, name=self.name)
+
+            # For each layer, generate a permutation of qubits
+            # Then generate and apply a Haar-random SU(4) to each pair
+            unitaries = scipy.stats.unitary_group.rvs(4, depth * width, rng).reshape(
+                depth, width, 4, 4
+            )
+            qubits = tuple(base.qubits)
+            for row in unitaries:
+                perm = rng.permutation(num_qubits)
                 base._append(CircuitInstruction(PermutationGate(perm), qubits))
                 for w, unitary in enumerate(row):
                     gate = UnitaryGate(unitary, check_input=False, num_qubits=2)
                     qubit = 2 * w
                     base._append(CircuitInstruction(gate, qubits[qubit : qubit + 2]))
-        if not flatten:
-            self._append(CircuitInstruction(base.to_instruction(), tuple(self.qubits)))
+            if not flatten:
+                self._append(CircuitInstruction(base.to_instruction(), tuple(self.qubits)))
 
 
 def quantum_volume(

releasenotes/notes/add-qv-function-a8990e248d5e7e1a.yaml

@@ -9,3 +9,20 @@ features_circuits:
     a :class:`.QuantumCircuit` object instead of building a subclass object. The second is
     that this new function is multithreaded and implemented in rust so it generates the output
     circuit ~10x faster than the :class:`.QuantumVolume` class.
+  - |
+    Improved the runtime performance of constructing the
+    :class:`.QuantumVolume` class with the ``classical_permutation`` argument set
+    to ``True``. Internally it now calls the :func:`.quantum_volume`
+    function which is written in Rust which is ~10x faster to generate a
+    quantum volume circuit.
+
+upgrade_circuits:
+  - |
+    The :class:`.QuantumVolume` class will generate circuits with
+    different unitary matrices and permutations for a given seed value from
+    the previous Qiskit release. This is due to using a new internal random
+    number generator for the circuit generation that will generate the circuit
+    more quickly. If you need an exact circuit with the same seed you can
+    use the previous release of Qiskit and generate the circuit with the
+    ``flatten=True`` argument and export the circuit with :func:`.qpy.dump`
+    and then load it with this release.