iqm-benchmarks 2.24__tar.gz → 2.26__tar.gz

{iqm_benchmarks-2.24 → iqm_benchmarks-2.26}/CHANGELOG.rst

@@ -2,6 +2,14 @@
 Changelog
 =========
 
+Version 2.26
+============
+* Changed benchmark observation names and identifiers to be more consistent with guidelines.
+
+Version 2.25
+============
+* Added optional configuration parameter (`max_circuits_per_batch`) to specify the maximum amount of circuits per batch.
+
 Version 2.24
 ============
 * Added rustworkx dependency range to fix wrong edge thickness assignment in qubit selection plot.

{iqm_benchmarks-2.24/src/iqm_benchmarks.egg-info → iqm_benchmarks-2.26}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.24
+Version: 2.26
 Summary: A package for implementation of Quantum Characterization, Verification and Validation (QCVV) techniques on IQM's hardware at gate level abstraction
 Author-email: IQM Finland Oy <developers@meetiqm.com>, Adrian Auer <adrian.auer@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Alessio Calzona <alessio.calzona@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Amin Hosseinkhani <amin.hosseinkhani@meetiqm.com>, Miikka Koistinen <miikka@meetiqm.com>, Nadia Milazzo <nadia.milazzo@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks
@@ -50,6 +50,7 @@ Provides-Extra: docs
 Requires-Dist: sphinx==7.2.6; extra == "docs"
 Requires-Dist: sphinx-book-theme==1.1.2; extra == "docs"
 Requires-Dist: myst-parser<5,>=4.0.0; extra == "docs"
+Dynamic: license-file
 
 # IQM Benchmarks
 
@@ -194,7 +195,7 @@ EXAMPLE_MRB = MirrorRBConfiguration(
 )
 
 EXAMPLE_QV = QuantumVolumeConfiguration(
-    num_circuits=500,
+    num_circuits=800,
     shots=2**8,
     calset_id=None,
     num_sigmas=2,
@@ -204,7 +205,8 @@ EXAMPLE_QV = QuantumVolumeConfiguration(
     optimize_sqg=True,
     routing_method="sabre",
     physical_layout="fixed",
-    max_gates_per_batch=60_000,
+    max_circuits_per_batch=500,
+    max_gates_per_batch=60_000, # Will be used if it renders a smaller max batch size than max_circuits_per_batch
     rem=True,
     mit_shots=1_000,
 )

{iqm_benchmarks-2.24 → iqm_benchmarks-2.26}/README.md

@@ -141,7 +141,7 @@ EXAMPLE_MRB = MirrorRBConfiguration(
 )
 
 EXAMPLE_QV = QuantumVolumeConfiguration(
-    num_circuits=500,
+    num_circuits=800,
     shots=2**8,
     calset_id=None,
     num_sigmas=2,
@@ -151,7 +151,8 @@ EXAMPLE_QV = QuantumVolumeConfiguration(
     optimize_sqg=True,
     routing_method="sabre",
     physical_layout="fixed",
-    max_gates_per_batch=60_000,
+    max_circuits_per_batch=500,
+    max_gates_per_batch=60_000, # Will be used if it renders a smaller max batch size than max_circuits_per_batch
     rem=True,
     mit_shots=1_000,
 )

{iqm_benchmarks-2.24 → iqm_benchmarks-2.26}/requirements.txt

@@ -929,9 +929,9 @@ llvmlite==0.43.0 \
     --hash=sha256:e0a9a1a39d4bf3517f2af9d23d479b4175ead205c592ceeb8b89af48a327ea57 \
     --hash=sha256:eccce86bba940bae0d8d48ed925f21dbb813519169246e2ab292b5092aba121f \
     --hash=sha256:f99b600aa7f65235a5a05d0b9a9f31150c390f31261f2a0ba678e26823ec38f7
-lmfit==1.3.2 \
-    --hash=sha256:2b834f054cd7a5172f3b431345b292e5d95ea387d6f96d60ad35a11b8efee6ac \
-    --hash=sha256:31beeae1f027c1b8c14dcd7f2e8488a80b75fb389e77fca677549bdc2fe597bb
+lmfit==1.3.3 \
+    --hash=sha256:73321e6b881f2f686235721a7dfc02af6bb0f030a25efeb66638f62b1c6053a1 \
+    --hash=sha256:a9e9ec7d0d0ec962cc6c078ad1ec6c8311d3ac0e5f0947a00a91f5509dacc2b2
 markdown-it-py==3.0.0 \
     --hash=sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1 \
     --hash=sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb
@@ -1505,38 +1505,38 @@ pyaml==25.1.0 \
 pycparser==2.22 \
     --hash=sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6 \
     --hash=sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc
-pycurl==7.45.4 \
-    --hash=sha256:0470bff6cc24d8c2f63c80931aa239463800871609dafc6bcc9ca10f5a12a04e \
-    --hash=sha256:1324a859b50bdb0abdbd5620e42f74240d0b7daf2d5925fa303695d9fc3ece18 \
-    --hash=sha256:13c4b18f44637859f34639493efd297a08670f45e4eec34ab2dcba724e3cb5fc \
-    --hash=sha256:13eb1643ab0bf4fdc539a2cdf1021029b07095d3196c5cee5a4271af268d3d31 \
-    --hash=sha256:236600bfe2cd72efe47333add621286667e8fa027dadf1247349afbf30333e95 \
-    --hash=sha256:247b4af8eab7d04137a7f1a98391930e04ea93dc669b64db5625070fe15f80a3 \
-    --hash=sha256:2548c3291a33c821f0f80bf9989fc43b5d90fb78b534a7015c8419b83c6f5803 \
-    --hash=sha256:26745c6c5ebdccfe8a828ac3fd4e6da6f5d2245696604f04529eb7894a02f4db \
-    --hash=sha256:32c8e237069273f4260b6ae13d1e0f99daae938977016021565dc6e11050e803 \
-    --hash=sha256:3452459668bd01d646385482362b021834a31c036aa1c02acd88924ddeff7d0d \
-    --hash=sha256:4f25d52c97dbca6ebea786f0961b49c1998fa05178abf1964a977c825b3d8ae6 \
-    --hash=sha256:561f88697f7540634b1c750146f37bdc0da367b15f6b4ab2bb780871ee6ab005 \
-    --hash=sha256:57971d7215fc6fdedcfc092f880a59f04f52fcaf2fd329151b931623d7b59a9c \
-    --hash=sha256:587a4891039803b5f48392066f97b7cd5e7e9a166187abb5cb4b4806fdb8fbef \
-    --hash=sha256:688d09ba2c6a0d4a749d192c43422839d73c40c85143c50cc65c944258fe0ba8 \
-    --hash=sha256:731c46e7c0acffaab19f7c2ecc3d9e7ee337500e87b260b4e0b9fae2d90fa133 \
-    --hash=sha256:73df3eb5940a7fbf4cf62f7271e9f23a8e9f80e352c838ee9a8448a70c01d3f5 \
-    --hash=sha256:9940e3234c1ca3d30f27a2202d325dbc25291605c98e9585100a351cacd935e8 \
-    --hash=sha256:9bd493ce598f1dc76c8e50043c47debec27c583fa313a836b2d3667640f875d5 \
-    --hash=sha256:a39f28f031885485325034918386be352036c220ca45625c7e286d3938eb579d \
-    --hash=sha256:acf25cfdaf914db21a2a6e9e274b6d95e3fa2b6018c38f2c58c94b5d8ac3d1b7 \
-    --hash=sha256:b0e38e3eb83b0c891f391853f798fc6a97cb5a86a4a731df0b6320e539ae54ae \
-    --hash=sha256:b485fdaf78553f0b8e1c2803bb7dcbe47a7b47594f846fc7e9d3b94d794cfc89 \
-    --hash=sha256:caec8b634763351dd4e1b729a71542b1e2de885d39710ba8e7202817a381b453 \
-    --hash=sha256:d14f954ecd21a070038d65ef1c6d1d3ab220f952ff703d48313123222097615c \
-    --hash=sha256:d192a48b3cec2e13ad432196b65c22e99620db92feae39c0476635354eff68c6 \
-    --hash=sha256:df5f94c051c5a163fa85064559ca94979575e2da26740ff91c078c50c541c465 \
-    --hash=sha256:e7ae49b88a5d57485fbabef004534225dfe04dc15716a61fae1a0c7f46f2279e \
-    --hash=sha256:f6c0e22052946bbfa25be67f9d1d6639eff10781c89f0cf6f3ff2099273d1bad \
-    --hash=sha256:fd167f73d34beb0cb8064334aee76d9bdd13167b30be6d5d36fb07d0c8223b71 \
-    --hash=sha256:ffd3262f98b8997ad04940061d5ebd8bab2362169b9440939c397e24a4a135b0
+pycurl==7.45.6 \
+    --hash=sha256:0cd6b7794268c17f3c660162ed6381769ce0ad260331ef49191418dfc3a2d61a \
+    --hash=sha256:1309fc0f558a80ca444a3a5b0bdb1572a4d72b195233f0e65413b4d4dd78809b \
+    --hash=sha256:26839d43dc7fff6b80e0067f185cc1d0e9be2ae6e2e2361ae8488cead5901c04 \
+    --hash=sha256:2a21e13278d7553a04b421676c458449f6c10509bebf04993f35154b06ee2b20 \
+    --hash=sha256:2b73e66b22719ea48ac08a93fc88e57ef36d46d03cb09d972063c9aa86bb74e6 \
+    --hash=sha256:2d1a49418b8b4c61f52e06d97b9c16142b425077bd997a123a2ba9ef82553203 \
+    --hash=sha256:334721ce1ccd71ff8e405470768b3d221b4393570ccc493fcbdbef4cd62e91ed \
+    --hash=sha256:3441ee77e830267aa6e2bb43b29fd5f8a6bd6122010c76a6f0bf84462e9ea9c7 \
+    --hash=sha256:357ea634395310085b9d5116226ac5ec218a6ceebf367c2451ebc8d63a6e9939 \
+    --hash=sha256:361bf94b2a057c7290f9ab84e935793ca515121fc012f4b6bef6c3b5e4ea4397 \
+    --hash=sha256:3fc0b505c37c7c54d88ced27e1d9e3241130987c24bf1611d9bbd9a3e499e07c \
+    --hash=sha256:56d1197eadd5774582b259cde4364357da71542758d8e917f91cc6ed7ed5b262 \
+    --hash=sha256:56f841b6f2f7a8b2d3051b9ceebd478599dbea3c8d1de8fb9333c895d0c1eea5 \
+    --hash=sha256:6f57ad26d6ab390391ad5030790e3f1a831c1ee54ad3bf969eb378f5957eeb0a \
+    --hash=sha256:7c09b7180799af70fc1d4eed580cfb1b9f34fda9081f73a3e3bc9a0e5a4c0e9b \
+    --hash=sha256:81005c0f681d31d5af694d1d3c18bbf1bed0bc8b2bb10fb7388cb1378ba9bd6a \
+    --hash=sha256:878ae64484db18f8f10ba99bffc83fefb4fe8f5686448754f93ec32fa4e4ee93 \
+    --hash=sha256:8a99e56d2575aa74c48c0cd08852a65d5fc952798f76a34236256d5589bf5aa0 \
+    --hash=sha256:942b352b69184cb26920db48e0c5cb95af39874b57dbe27318e60f1e68564e37 \
+    --hash=sha256:9f721e3394e5bd7079802ec1819b19c5be4842012268cc45afcb3884efb31cf0 \
+    --hash=sha256:a554a2813d415a7bb9a996a6298f3829f57e987635dcab9f1197b2dccd0ab3b2 \
+    --hash=sha256:a721c2696a71b1aa5ecf82e6d0ade64bc7211b7317f1c9c66e82f82e2264d8b4 \
+    --hash=sha256:abe1b204a2f96f2eebeaf93411f03505b46d151ef6d9d89326e6dece7b3a008a \
+    --hash=sha256:ae893144b82d72d95c932ebdeb81fc7e9fde758e5ecd5dd10ad5b67f34a8b8ee \
+    --hash=sha256:bb9eff0c7794af972da769a887c87729f1bcd8869297b1c01a2732febbb75876 \
+    --hash=sha256:c04230b9e9cfdca9cf3eb09a0bec6cf2f084640f1f1ca1929cca51411af85de2 \
+    --hash=sha256:c31b390f1e2cd4525828f1bb78c1f825c0aab5d1588228ed71b22c4784bdb593 \
+    --hash=sha256:c6fd295f03c928da33a00f56c91765195155d2ac6f12878f6e467830b5dce5f5 \
+    --hash=sha256:c872d4074360964697c39c1544fe8c91bfecbff27c1cdda1fee5498e5fdadcda \
+    --hash=sha256:d0b5501d527901369aba307354530050f56cd102410f2a3bacd192dc12c645e3 \
+    --hash=sha256:f0198ebcda8686b3a0c66d490a687fa5fd466f8ecc2f20a0ed0931579538ae3d
 pydantic==2.9.2 \
     --hash=sha256:d155cef71265d1e9807ed1c32b4c8deec042a44a50a4188b25ac67ecd81a9c0f \
     --hash=sha256:f048cec7b26778210e28a0459867920654d48e5e62db0958433636cde4254f12

{iqm_benchmarks-2.24 → iqm_benchmarks-2.26}/src/iqm/benchmarks/benchmark.py

@@ -51,6 +51,7 @@ class BenchmarkBase(ABC):
         self.shots = self.configuration.shots
         self.calset_id = self.configuration.calset_id
         self.max_gates_per_batch = self.configuration.max_gates_per_batch
+        self.max_circuits_per_batch = self.configuration.max_circuits_per_batch
 
         self.routing_method = self.configuration.routing_method
         self.physical_layout = self.configuration.physical_layout
@@ -92,6 +93,8 @@ class BenchmarkConfigurationBase(BaseModel):
                 * Default for all benchmarks is 2**8.
         max_gates_per_batch (Optional[int]): the maximum number of gates per circuit batch.
                 * Default for all benchmarks is None.
+        max_circuits_per_batch (Optional[int]): the maximum number of circuits per batch.
+                * Default for all benchmarks is None.
         calset_id (Optional[str]): the calibration ID to use in circuit execution.
                 * Default for all benchmarks is None (uses last available calibration ID).
         routing_method (Literal["basic", "lookahead", "stochastic", "sabre", "none"]): the Qiskit routing method to use in transpilation.
@@ -100,13 +103,14 @@ class BenchmarkConfigurationBase(BaseModel):
                 - "fixed": physical layout is constrained during transpilation to the selected initial physical qubits.
                 - "batching": physical layout is allowed to use any other physical qubits, and circuits are batched according to final measured qubits.
                 * Default for all benchmarks is "fixed".
-        use_DD (bool): Boolean flag determining if dynamical decoupling is enabled during circuit execution
+        use_dd (bool): Boolean flag determining whether to enable dynamical decoupling during circuit execution.
             * Default: False
     """
 
     benchmark: Type[BenchmarkBase]
     shots: int = 2**8
     max_gates_per_batch: Optional[int] = None
+    max_circuits_per_batch: Optional[int] = None
     calset_id: Optional[str] = None
     routing_method: Literal["basic", "lookahead", "stochastic", "sabre", "none"] = "sabre"
     physical_layout: Literal["fixed", "batching"] = "fixed"

{iqm_benchmarks-2.24 → iqm_benchmarks-2.26}/src/iqm/benchmarks/compressive_gst/compressive_gst.py

@@ -81,10 +81,7 @@ class CompressiveGST(Benchmark):
         if configuration.opt_method not in ["GD", "SFN", "auto"]:
             raise ValueError("Invalid optimization method, valid options are: GD, SFN, auto")
         if configuration.opt_method == "auto":
-            if (self.num_qubits == 2 and configuration.rank > 2) or self.num_qubits > 2:
-                self.opt_method = "GD"
-            else:
-                self.opt_method = "SFN"
+            self.opt_method = "GD"  # Currently the fastest method in all cases
         else:
             self.opt_method = configuration.opt_method
 
@@ -160,17 +157,23 @@ class CompressiveGST(Benchmark):
                     "Qubit layouts can't overlap when parallel_execution is enabled, please choose non-overlapping layouts."
                 )
             raw_qc_list_parallel = []
+            if "move" in self.backend.operation_names:
+                backend_qubits = np.arange(1, self.backend.num_qubits)
+                qubit_layouts = [[q - 1 for q in layout] for layout in self.qubit_layouts]
+            else:
+                backend_qubits = np.arange(self.backend.num_qubits)
+                qubit_layouts = self.qubit_layouts
             for circ in raw_qc_list:
-                circ_parallel = QuantumCircuit(self.backend.num_qubits, len(set(all_qubits)))
+                circ_parallel = QuantumCircuit(len(backend_qubits), len(set(all_qubits)))
                 clbits = np.arange(self.num_qubits)
-                for qubit_layout in self.qubit_layouts:
+                for qubit_layout in qubit_layouts:
                     circ_parallel.compose(circ, qubits=qubit_layout, clbits=clbits, inplace=True)
                     clbits += self.num_qubits
                 raw_qc_list_parallel.append(circ_parallel)
             transpiled_qc_list, _ = perform_backend_transpilation(
                 raw_qc_list_parallel,
                 self.backend,
-                qubits=np.arange(self.backend.num_qubits),
+                qubits=backend_qubits,
                 coupling_map=self.backend.coupling_map,
                 qiskit_optim_level=0,
                 optimize_sqg=False,
@@ -239,6 +242,7 @@ class CompressiveGST(Benchmark):
                 self.configuration.shots,
                 self.calset_id,
                 max_gates_per_batch=self.configuration.max_gates_per_batch,
+                max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                 circuit_compilation_options=self.circuit_compilation_options,
             )
             # Retrieve
@@ -255,6 +259,7 @@ class CompressiveGST(Benchmark):
                     self.configuration.shots,
                     self.calset_id,
                     max_gates_per_batch=self.configuration.max_gates_per_batch,
+                    max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                 )
             # Retrieve all
             qcvv_logger.info(f"Now executing the corresponding circuit batch")
@@ -386,7 +391,7 @@ def parse_gate_set(
         gate_set: List[QuantumCircuit]
             A list of gates defined as quantum circuit objects
         gate_labels_dict: Dict[str, Dict[int, str]]
-            The names of gates, i.e. "Rx(pi/2)" for a pi/2 rotation around the x-axis.
+            The names of gates, i.e. "Rx_pi_2" for a pi/2 rotation around the x-axis.
         num_gates: int
             The number of gates in the gate set
 
@@ -445,7 +450,7 @@ def create_predefined_gate_set(
         gates: List[QuantumCircuit]
             The gate set as a list of circuits
         gate_labels_dict: Dict[str, Dict[int, str]]
-            The names of gates, i.e. "Rx(pi/2)" for a pi/2 rotation around the x-axis.
+            The names of gates, i.e. "Rx_pi_2" for a pi/2 rotation around the x-axis.
         num_gates: int
             The number of gates in the gate set
 
@@ -458,7 +463,7 @@ def create_predefined_gate_set(
         gate_qubits = [[0], [0], [0]]
         for i, gate in enumerate(gate_list):
             gates[i].append(gate, gate_qubits[i])
-        gate_labels = ["Idle", "Rx(pi/2)", "Ry(pi/2)"]
+        gate_labels = ["Idle", "Rx_pi_2", "Ry_pi_2"]
     elif gate_set == "2QXYCZ":
         gate_qubits = [[0], [1], [0], [1], [0, 1]]
         gates = [QuantumCircuit(num_qubits, 0) for _ in range(5)]
@@ -467,7 +472,7 @@ def create_predefined_gate_set(
         gates[2].append(RGate(0.5 * np.pi, np.pi / 2), [0])
         gates[3].append(RGate(0.5 * np.pi, np.pi / 2), [1])
         gates[4].append(CZGate(), [0, 1])
-        gate_labels = ["Rx(pi/2)", "Rx(pi/2)", "Ry(pi/2)", "Ry(pi/2)", "CZ"]
+        gate_labels = ["Rx_pi_2", "Rx_pi_2", "Ry_pi_2", "Ry_pi_2", "cz"]
     elif gate_set == "2QXYCZ_extended":
         gate_qubits = [[0], [1], [0], [1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1]]
         gates = [QuantumCircuit(num_qubits, 0) for _ in range(9)]
@@ -485,14 +490,14 @@ def create_predefined_gate_set(
         gates[7].append(RGate(0.5 * np.pi, np.pi / 2), [1])
         gates[8].append(CZGate(), [[0], [1]])
         gate_labels = [
-            "Rx(pi/2)",
-            "Rx(pi/2)",
-            "Ry(pi/2)",
-            "Ry(pi/2)",
-            "Rx(pi/2)-Rx(pi/2)",
-            "Rx(pi/2)-Ry(pi/2)",
-            "Ry(pi/2)-Rx(pi/2)",
-            "Ry(pi/2)-Ry(pi/2)",
+            "Rx_pi_2",
+            "Rx_pi_2",
+            "Ry_pi_2",
+            "Ry_pi_2",
+            "Rx_pi_2-Rx_pi_2",
+            "Rx_pi_2-Ry_pi_2",
+            "Ry_pi_2-Rx_pi_2",
+            "Ry_pi_2-Ry_pi_2",
             "CZ",
         ]
     elif gate_set == "3QXYCZ":
@@ -510,7 +515,7 @@ def create_predefined_gate_set(
         gate_qubits = [[0], [1], [2], [0], [1], [2], [0, 1], [0, 2]]
         for i, gate in enumerate(gate_list):
             gates[i].append(gate, gate_qubits[i])
-        gate_labels = ["Rx(pi/2)", "Rx(pi/2)", "Rx(pi/2)", "Ry(pi/2)", "Ry(pi/2)", "Ry(pi/2)", "CZ", "CZ"]
+        gate_labels = ["Rx_pi_2", "Rx_pi_2", "Rx_pi_2", "Ry_pi_2", "Ry_pi_2", "Ry_pi_2", "cz", "cz"]
     else:
         raise ValueError(
             f"Invalid gate set, choose among 1QXYI, 2QXYCZ, 2QXYCZ_extended,"
@@ -526,6 +531,6 @@ def create_predefined_gate_set(
         iqm_qubits = [f"QB{q + 1}" for q in qubit_layout]
         gate_qubits_iqm = [(iqm_qubits[q] for q in qubits) for qubits in gate_qubits]
         for key, value in layout_label_dict.items():
-            layout_label_dict[key] = value + ":" + "-".join(gate_qubits_iqm[key])
+            layout_label_dict[key] = value + ":" + "__".join(gate_qubits_iqm[key])
         gate_label_dict.update({BenchmarkObservationIdentifier(qubit_layout).string_identifier: layout_label_dict})
     return gates, gate_label_dict, len(gates)

{iqm_benchmarks-2.24 → iqm_benchmarks-2.26}/src/iqm/benchmarks/compressive_gst/gst_analysis.py

@@ -2,6 +2,7 @@
 Data analysis code for compressive gate set tomography
 """
 
+import ast
 from itertools import product
 from time import perf_counter
 from typing import Any, List, Tuple, Union
@@ -218,16 +219,16 @@ def generate_non_gate_results(
         percentiles_o_low, percentiles_o_high = np.nanpercentile(df_o_array, [2.5, 97.5], axis=0)
         df_o_final = DataFrame(
             {
-                f"Mean TVD: estimate - data": reporting.number_to_str(
+                f"mean_total_variation_distance_estimate_data": reporting.number_to_str(
                     df_o.values[0, 1].copy(), [percentiles_o_high[0, 1], percentiles_o_low[0, 1]], precision=5
                 ),
-                f"Mean TVD: target - data": reporting.number_to_str(
+                f"mean_total_variation_distance_target_data": reporting.number_to_str(
                     df_o.values[0, 2].copy(), [percentiles_o_high[0, 2], percentiles_o_low[0, 2]], precision=5
                 ),
-                f"POVM - diamond dist.": reporting.number_to_str(
+                f"povm_diamond_distance": reporting.number_to_str(
                     df_o.values[0, 3].copy(), [percentiles_o_high[0, 3], percentiles_o_low[0, 3]], precision=5
                 ),
-                f"State - trace dist.": reporting.number_to_str(
+                f"state_trace_distance": reporting.number_to_str(
                     df_o.values[0, 4].copy(), [percentiles_o_high[0, 4], percentiles_o_low[0, 4]], precision=5
                 ),
             },
@@ -236,10 +237,10 @@ def generate_non_gate_results(
     else:
         df_o_final = DataFrame(
             {
-                f"Mean TVD: estimate - data": reporting.number_to_str(df_o.values[0, 1].copy(), precision=5),
-                f"Mean TVD: target - data": reporting.number_to_str(df_o.values[0, 2].copy(), precision=5),
-                f"POVM - diamond dist.": reporting.number_to_str(df_o.values[0, 3].copy(), precision=5),
-                f"State - trace dist.": reporting.number_to_str(df_o.values[0, 4].copy(), precision=5),
+                f"mean_total_variation_distance_estimate_data": reporting.number_to_str(df_o.values[0, 1].copy(), precision=5),
+                f"mean_total_variation_distance_target_data": reporting.number_to_str(df_o.values[0, 2].copy(), precision=5),
+                f"povm_diamond_distance": reporting.number_to_str(df_o.values[0, 3].copy(), precision=5),
+                f"state_trace_distance": reporting.number_to_str(df_o.values[0, 4].copy(), precision=5),
             },
             index=[""],
         )
@@ -290,13 +291,13 @@ def generate_unit_rank_gate_results(
 
         df_g_final = DataFrame(
             {
-                r"Avg. gate fidelity": [
+                r"average_gate_fidelity": [
                     reporting.number_to_str(
                         df_g.values[i, 0], [percentiles_g_high[i, 0], percentiles_g_low[i, 0]], precision=5
                     )
                     for i in range(len(dataset.attrs["gate_labels"][identifier]))
                 ],
-                r"Diamond distance": [
+                r"diamond_distance": [
                     reporting.number_to_str(
                         df_g.values[i, 1], [percentiles_g_high[i, 1], percentiles_g_low[i, 1]], precision=5
                     )
@@ -338,10 +339,10 @@ def generate_unit_rank_gate_results(
     else:
         df_g_final = DataFrame(
             {
-                "Avg. gate fidelity": [
+                "average_gate_fidelity": [
                     reporting.number_to_str(df_g.values[i, 0], precision=5) for i in range(dataset.attrs["num_gates"])
                 ],
-                "Diamond distance": [
+                "diamond_distance": [
                     reporting.number_to_str(df_g.values[i, 1], precision=5) for i in range(dataset.attrs["num_gates"])
                 ],
             }
@@ -442,19 +443,19 @@ def generate_gate_results(
 
         df_g_final = DataFrame(
             {
-                r"Avg. gate fidelity": [
+                r"average_gate_fidelity": [
                     reporting.number_to_str(
                         df_g.values[i, 0], [percentiles_g_high[i, 0], percentiles_g_low[i, 0]], precision=5
                     )
                     for i in range(dataset.attrs["num_gates"])
                 ],
-                r"Diamond distance": [
+                r"diamond_distance": [
                     reporting.number_to_str(
                         df_g.values[i, 1], [percentiles_g_high[i, 1], percentiles_g_low[i, 1]], precision=5
                     )
                     for i in range(dataset.attrs["num_gates"])
                 ],
-                r"Unitarity": [
+                r"unitarity": [
                     reporting.number_to_str(
                         reporting.unitarities(X_opt_pp)[i],
                         [percentiles_u_high[i], percentiles_u_low[i]],
@@ -468,15 +469,15 @@ def generate_gate_results(
     else:
         df_g_final = DataFrame(
             {
-                "Avg. gate fidelity": [
+                "average_gate_fidelity": [
                     reporting.number_to_str(df_g.values[i, 0].copy(), precision=5)
                     for i in range(len(dataset.attrs["gate_labels"][identifier]))
                 ],
-                "Diamond distance": [
+                "diamond_distance": [
                     reporting.number_to_str(df_g.values[i, 1].copy(), precision=5)
                     for i in range(len(dataset.attrs["gate_labels"][identifier]))
                 ],
-                "Unitarity": [
+                "unitarity": [
                     reporting.number_to_str(reporting.unitarities(X_opt_pp)[i], precision=5)
                     for i in range(len(dataset.attrs["gate_labels"][identifier]))
                 ],
@@ -574,11 +575,12 @@ def pandas_results_to_observations(
     """
     observation_list: list[BenchmarkObservation] = []
     err = dataset.attrs["bootstrap_samples"] > 0
+    qubits = "__".join([f"QB{i+1}" for i in ast.literal_eval(identifier.string_identifier)])
     for idx, gate_label in enumerate(dataset.attrs["gate_labels"][identifier.string_identifier].values()):
         observation_list.extend(
             [
                 BenchmarkObservation(
-                    name=f"{name} - {gate_label}",
+                    name=f"{name}_{gate_label}:crosstalk_components={qubits}",
                     identifier=identifier,
                     value=result_str_to_floats(df_g[name].iloc[idx], err)[0],
                     uncertainty=result_str_to_floats(df_g[name].iloc[idx], err)[1],
@@ -754,6 +756,7 @@ def mgst_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     dataset = run.dataset
     pdim = dataset.attrs["pdim"]
     plots = {}
+    observations = []
     for i, qubit_layout in enumerate(dataset.attrs["qubit_layouts"]):
         identifier = BenchmarkObservationIdentifier(qubit_layout).string_identifier
 
@@ -820,8 +823,10 @@ def mgst_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
         plots[f"layout_{qubit_layout}_gate_metrics"] = fig_g
         plots[f"layout_{qubit_layout}_other_metrics"] = fig_o
 
-        observation_list = pandas_results_to_observations(
-            dataset, df_g_final, df_o_final, BenchmarkObservationIdentifier(qubit_layout)
+        observations.extend(
+            pandas_results_to_observations(
+                dataset, df_g_final, df_o_final, BenchmarkObservationIdentifier(qubit_layout)
+            )
         )
 
         dataset.attrs["results_layout_" + identifier].update(
@@ -865,4 +870,4 @@ def mgst_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
         )
         plt.close("all")
 
-    return BenchmarkAnalysisResult(dataset=dataset, observations=observation_list, plots=plots)
+    return BenchmarkAnalysisResult(dataset=dataset, observations=observations, plots=plots)

{iqm_benchmarks-2.24 → iqm_benchmarks-2.26}/src/iqm/benchmarks/entanglement/ghz.py

@@ -851,6 +851,7 @@ class GHZBenchmark(Benchmark):
                 self.shots,
                 self.calset_id,
                 max_gates_per_batch=self.max_gates_per_batch,
+                max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                 circuit_compilation_options=self.circuit_compilation_options,
             )
 

{iqm_benchmarks-2.24 → iqm_benchmarks-2.26}/src/iqm/benchmarks/optimization/qscore.py

@@ -475,23 +475,24 @@ def qscore_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
             qcvv_logger.info(
                 f"Q-Score = {num_nodes} failed with approximation ratio (Beta) {approximation_ratio:.4f} < 0.2; Avg MaxCut size: {np.mean(cut_sizes_list):.4f}"
             )
+        qubit_indices = dataset.attrs[num_nodes]["qubit_set"][0]
         observations.extend(
             [
                 BenchmarkObservation(
                     name="mean_approximation_ratio",
                     value=approximation_ratio,
                     uncertainty=std_of_approximation_ratio,
-                    identifier=BenchmarkObservationIdentifier(num_nodes),
+                    identifier=BenchmarkObservationIdentifier(qubit_indices),
                 ),
                 BenchmarkObservation(
                     name="is_succesful",
                     value=str(success),
-                    identifier=BenchmarkObservationIdentifier(num_nodes),
+                    identifier=BenchmarkObservationIdentifier(qubit_indices),
                 ),
                 BenchmarkObservation(
                     name="Qscore_result",
                     value=qscore if success else 1,
-                    identifier=BenchmarkObservationIdentifier(num_nodes),
+                    identifier=BenchmarkObservationIdentifier(qubit_indices),
                 ),
             ]
         )
@@ -751,7 +752,7 @@ class QScoreBenchmark(Benchmark):
         else:
             nqubits = self.backend.num_qubits
 
-        if self.custom_qubits_array is not None:
+        if self.choose_qubits_routine == "custom":
             if self.use_virtual_node:
                 node_numbers = [len(qubit_layout) + 1 for qubit_layout in self.custom_qubits_array]
             else:
@@ -765,7 +766,7 @@ class QScoreBenchmark(Benchmark):
                     max_num_nodes = nqubits
             else:
                 max_num_nodes = self.max_num_nodes
-            node_numbers = range(self.min_num_nodes, max_num_nodes + 1)
+            node_numbers = list(range(self.min_num_nodes, max_num_nodes + 1))
 
         dataset.attrs.update({"max_num_nodes": node_numbers[-1]})
         dataset.attrs.update({"node_numbers": node_numbers})
@@ -881,6 +882,7 @@ class QScoreBenchmark(Benchmark):
                         self.shots,
                         self.calset_id,
                         max_gates_per_batch=self.max_gates_per_batch,
+                        max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                         circuit_compilation_options=self.circuit_compilation_options,
                     )
                     qc_transpiled_list.append(transpiled_qc)

{iqm_benchmarks-2.24 → iqm_benchmarks-2.26}/src/iqm/benchmarks/quantum_volume/clops.py

@@ -565,6 +565,7 @@ class CLOPSBenchmark(Benchmark):
             self.num_shots,
             self.calset_id,
             max_gates_per_batch=self.max_gates_per_batch,
+            max_circuits_per_batch=self.configuration.max_circuits_per_batch,
             circuit_compilation_options=self.circuit_compilation_options,
         )
 

{iqm_benchmarks-2.24 → iqm_benchmarks-2.26}/src/iqm/benchmarks/quantum_volume/quantum_volume.py

@@ -26,7 +26,7 @@ from mthree.classes import QuasiCollection
 from mthree.utils import expval
 import numpy as np
 from qiskit.circuit.library import QuantumVolume
-from qiskit_aer import Aer
+from qiskit_aer import StatevectorSimulator
 import xarray as xr
 
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
@@ -119,7 +119,7 @@ def get_ideal_heavy_outputs(
     """
     simulable_circuits = deepcopy(qc_list)
     ideal_heavy_outputs: List[Dict[str, float]] = []
-    ideal_simulator = Aer.get_backend("statevector_simulator")
+    ideal_simulator = StatevectorSimulator()
 
     # Separate according to sorted indices
     circuit_batches = {
@@ -698,6 +698,7 @@ class QuantumVolumeBenchmark(Benchmark):
             self.shots,
             self.calset_id,
             max_gates_per_batch=self.max_gates_per_batch,
+            max_circuits_per_batch=self.configuration.max_circuits_per_batch,
             circuit_compilation_options=self.circuit_compilation_options,
         )
         # qcvv_logger.info(

{iqm_benchmarks-2.24 → iqm_benchmarks-2.26}/src/iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py

@@ -125,13 +125,18 @@ def clifford_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
         fidelity = rb_fit_results.params["fidelity_per_clifford"]
 
         processed_results = {
-            "avg_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
+            "average_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
         }
 
         if len(qubits) == 1:
             fidelity_native = rb_fit_results.params["fidelity_per_native_sqg"]
             processed_results.update(
-                {"avg_native_gate_fidelity": {"value": fidelity_native.value, "uncertainty": fidelity_native.stderr}}
+                {
+                    "average_native_gate_fidelity": {
+                        "value": fidelity_native.value,
+                        "uncertainty": fidelity_native.stderr,
+                    }
+                }
             )
 
         dataset.attrs[qubits_idx].update(
@@ -140,8 +145,8 @@ def clifford_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
                 "fit_amplitude": {"value": popt["amplitude"].value, "uncertainty": popt["amplitude"].stderr},
                 "fit_offset": {"value": popt["offset"].value, "uncertainty": popt["offset"].stderr},
                 "fidelities": fidelities[str(qubits)],
-                "avg_fidelities_nominal_values": average_fidelities,
-                "avg_fidelities_stderr": stddevs_from_mean,
+                "average_fidelities_nominal_values": average_fidelities,
+                "average_fidelities_stderr": stddevs_from_mean,
                 "fitting_method": str(rb_fit_results.method),
                 "num_function_evals": int(rb_fit_results.nfev),
                 "data_points": int(rb_fit_results.ndata),
@@ -294,6 +299,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
                         self.shots,
                         self.calset_id,
                         self.max_gates_per_batch,
+                        self.configuration.max_circuits_per_batch,
                     )
                 )
                 qcvv_logger.info(f"Job for sequence length {seq_length} submitted successfully!")
@@ -353,6 +359,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
                         self.backend,
                         self.calset_id,
                         max_gates_per_batch=self.max_gates_per_batch,
+                        max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                         circuit_compilation_options=self.circuit_compilation_options,
                     )
                 )