iqm-benchmarks 2.39__tar.gz → 2.40__tar.gz

{iqm_benchmarks-2.39 → iqm_benchmarks-2.40}/CHANGELOG.rst

@@ -2,6 +2,10 @@
 Changelog
 =========
 
+Version 2.40
+============
+* Added optimise_single_qubit_gates option for crystal processors.
+
 Version 2.39
 ============
 * Relax `numba` dependency to allow easier interoperability with other client libraries.

{iqm_benchmarks-2.39/src/iqm_benchmarks.egg-info → iqm_benchmarks-2.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.39
+Version: 2.40
 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

{iqm_benchmarks-2.39 → iqm_benchmarks-2.40}/requirements.txt

@@ -824,18 +824,18 @@ ipykernel==6.29.5 \
 ipython==8.31.0 \
     --hash=sha256:46ec58f8d3d076a61d128fe517a51eb730e3aaf0c184ea8c17d16e366660c6a6 \
     --hash=sha256:b6a2274606bec6166405ff05e54932ed6e5cfecaca1fc05f2cacde7bb074d70b
-iqm-client==29.0.0 \
-    --hash=sha256:7b050f37ffa0b5807b62d32919119ebfa01d76b1fb2ca25f26211ec229f8686b \
-    --hash=sha256:fc91e50f3ad0f619700182f28e561526af27285708f86eeef49a912961fa84a0
+iqm-client==29.3.0 \
+    --hash=sha256:4fc8494056ff03babf7fda3826fefd087ce24d58cd1101455f0c4819f68ced20 \
+    --hash=sha256:e553e97ab23a150ae94908ee19cbea86e46814fe48085c05596fe90db72d2c6a
 iqm-data-definitions==2.13 \
     --hash=sha256:0de52e2a1ffdc63375b13825b28170d0868b12cda011e782b9348bb143083a0e \
     --hash=sha256:be6a71ab2e5b04c6e6c4d53094c89c088cc4b6e8e293f412f9fa937cf8dc980c
 iqm-exa-common==26.24.0 \
     --hash=sha256:92e880913589015b78baf8e0267f82cadc8a52cb090c8e7b5226d1d9a8ddbd26 \
     --hash=sha256:fc3edd89b501961b3ad034f4c37983bb879735626df4f342ea0edcab3bce8182
-iqm-station-control-client==9.3.0 \
-    --hash=sha256:1f21e12d3160100f5ba82bb737ed08f7faa41625f87c99db6c940f7069420598 \
-    --hash=sha256:557889329d25cf2953cdbdaf24b6079f542e014d2ae5e9aa2ceb877edd097c76
+iqm-station-control-client==9.4.0 \
+    --hash=sha256:1cd6262ce8b84a6ebd7eeb763e752962d47d23271e47dde2f6bcdfbf75add36d \
+    --hash=sha256:e893ea59bdbbb1a348e386a501e898417a202d21621ca3a00e57d11ae1f5b927
 isoduration==20.11.0 \
     --hash=sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9 \
     --hash=sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042

{iqm_benchmarks-2.39 → iqm_benchmarks-2.40}/src/iqm/benchmarks/utils.py

@@ -40,7 +40,7 @@ import xarray as xr
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.iqm_client.models import CircuitCompilationOptions
 from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
-from iqm.qiskit_iqm import IQMFakeDeneb, transpile_to_IQM
+from iqm.qiskit_iqm import IQMFakeDeneb, optimize_single_qubit_gates, transpile_to_IQM
 from iqm.qiskit_iqm.fake_backends.fake_adonis import IQMFakeAdonis
 from iqm.qiskit_iqm.fake_backends.fake_apollo import IQMFakeApollo
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
@@ -575,6 +575,8 @@ def perform_backend_transpilation(
             initial_layout=qubits if aux_qc is None else None,
             routing_method=routing_method,
         )
+        if optimize_sqg:
+            transpiled = optimize_single_qubit_gates(transpiled, drop_final_rz=drop_final_rz)
         if backend.has_resonators():
             transpiled = transpile_to_IQM(
                 qc, backend=backend, optimize_single_qubits=optimize_sqg, remove_final_rzs=drop_final_rz

{iqm_benchmarks-2.39 → iqm_benchmarks-2.40/src/iqm_benchmarks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.39
+Version: 2.40
 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

{iqm_benchmarks-2.39 → iqm_benchmarks-2.40}/tests/test_ghz.py

@@ -6,6 +6,7 @@ from iqm.benchmarks.entanglement.ghz import GHZBenchmark, GHZConfiguration
 from iqm.qiskit_iqm.fake_backends.fake_apollo import IQMFakeApollo
 from iqm.qiskit_iqm.fake_backends.fake_deneb import IQMFakeDeneb
 
+
 class TestGHZ:
     backend = IQMFakeApollo()
 
@@ -25,7 +26,7 @@ class TestGHZ:
             num_RMs=10,
             rem=False,
             mit_shots=10,
-            use_dd = True
+            use_dd=True,
         )
         benchmark = GHZBenchmark(self.backend, MINIMAL_GHZ)
         benchmark.run()
@@ -70,5 +71,6 @@ class TestGHZ:
             benchmark.analyze()
             mock_fig.assert_called()
 
+
 class TestGHZDeneb(TestGHZ):
-    backend = IQMFakeDeneb()
+    backend = IQMFakeDeneb()

{iqm_benchmarks-2.39 → iqm_benchmarks-2.40}/tests/test_graph_states.py

@@ -4,7 +4,10 @@ from unittest.mock import patch
 
 from iqm.benchmarks.entanglement.graph_states import *
 from iqm.qiskit_iqm.fake_backends.fake_apollo import IQMFakeApollo
-#from iqm.qiskit_iqm.fake_backends.fake_deneb import IQMFakeDeneb
+
+
+# from iqm.qiskit_iqm.fake_backends.fake_deneb import IQMFakeDeneb
+
 
 class TestGraphState:
     backend = IQMFakeApollo()
@@ -13,7 +16,7 @@ class TestGraphState:
     def test_state_tomo(self, mock_fig):
         MINIMAL_GRAPHSTATE = GraphStateConfiguration(
             qubits=list(range(5)),
-            shots=2 ** 10,
+            shots=2**10,
             tomography="state_tomography",
             num_bootstraps=10,
         )
@@ -26,7 +29,7 @@ class TestGraphState:
     def test_shadows(self, mock_fig):
         MINIMAL_GRAPHSTATE = GraphStateConfiguration(
             qubits=list(range(5)),
-            shots=2 ** 6,
+            shots=2**6,
             tomography="shadow_tomography",
             num_bootstraps=2,
             n_random_unitaries=10,
@@ -37,5 +40,6 @@ class TestGraphState:
         benchmark.analyze()
         mock_fig.assert_called()
 
+
 # class TestGraphStateDeneb(TestGraphState):
-#     backend = IQMFakeDeneb()
+#     backend = IQMFakeDeneb()

{iqm_benchmarks-2.39 → iqm_benchmarks-2.40}/tests/test_gst.py

@@ -43,5 +43,6 @@ class TestGST:
         benchmark.analyze()
         mock_fig.assert_called()
 
+
 class TestGSTDeneb(TestGST):
-    backend = IQMFakeDeneb()
+    backend = IQMFakeDeneb()

{iqm_benchmarks-2.39 → iqm_benchmarks-2.40}/tests/test_qscore.py

@@ -7,7 +7,7 @@ from iqm.qiskit_iqm.fake_backends.fake_deneb import IQMFakeDeneb
 
 class TestQScore:
     backend = IQMFakeApollo()
-    custom_qubits_array = [[0, 1, 3], [0, 1, 2, 3] , [0, 1, 2, 3, 4]]
+    custom_qubits_array = [[0, 1, 3], [0, 1, 2, 3], [0, 1, 2, 3, 4]]
 
     def test_qscore(self):
         EXAMPLE_QSCORE = QScoreConfiguration(
@@ -29,6 +29,7 @@ class TestQScore:
         benchmark.run()
         benchmark.analyze()
 
+
 class TestQScoreDeneb(TestQScore):
     backend = IQMFakeDeneb()
-    custom_qubits_array = [[1], [1, 2], [1, 2, 3, 4], [1, 2, 3, 4, 5]]
+    custom_qubits_array = [[1], [1, 2], [1, 2, 3, 4], [1, 2, 3, 4, 5]]

{iqm_benchmarks-2.39 → iqm_benchmarks-2.40}/tests/test_qv.py

@@ -46,5 +46,6 @@ class TestQV:
         benchmark.run()
         benchmark.analyze()
 
+
 class TestQVDeneb(TestQV):
-    backend = IQMFakeDeneb()
+    backend = IQMFakeDeneb()

{iqm_benchmarks-2.39 → iqm_benchmarks-2.40}/tests/test_rb.py

@@ -6,6 +6,7 @@ from iqm.benchmarks.randomized_benchmarking.clifford_rb.clifford_rb import (
     CliffordRandomizedBenchmarking,
     CliffordRBConfiguration,
 )
+from iqm.benchmarks.randomized_benchmarking.eplg.eplg import EPLGBenchmark, EPLGConfiguration
 from iqm.benchmarks.randomized_benchmarking.interleaved_rb.interleaved_rb import (
     InterleavedRandomizedBenchmarking,
     InterleavedRBConfiguration,
@@ -14,13 +15,10 @@ from iqm.benchmarks.randomized_benchmarking.mirror_rb.mirror_rb import (
     MirrorRandomizedBenchmarking,
     MirrorRBConfiguration,
 )
-from iqm.benchmarks.randomized_benchmarking.eplg.eplg import (
-    EPLGConfiguration,
-    EPLGBenchmark,
-)
 from iqm.qiskit_iqm.fake_backends.fake_apollo import IQMFakeApollo
 from iqm.qiskit_iqm.fake_backends.fake_deneb import IQMFakeDeneb
 
+
 class TestRB:
     backend = IQMFakeApollo()
 
@@ -70,7 +68,7 @@ class TestRB:
 
     def test_eplg(self):
         EXAMPLE_EPLG = EPLGConfiguration(
-            custom_qubits_array=[[0,1],[1,4],[4,5]],
+            custom_qubits_array=[[0, 1], [1, 4], [4, 5]],
             drb_depths=sorted(list(set(np.geomspace(1, 100, num=5, endpoint=True, dtype=int).tolist())), reverse=True),
             drb_circuit_samples=5,
             shots=2**8,
@@ -81,5 +79,6 @@ class TestRB:
         benchmark.run()
         benchmark.analyze()
 
+
 class TestRBDeneb(TestRB):
-    backend = IQMFakeDeneb()
+    backend = IQMFakeDeneb()

{iqm_benchmarks-2.39 → iqm_benchmarks-2.40}/tests/unit/test_backend_transpilation.py

@@ -1,10 +1,14 @@
 import unittest
+
 import numpy as np
 from qiskit import QuantumCircuit
-from iqm.qiskit_iqm import transpile_to_IQM
 from qiskit.quantum_info import Operator
+from scipy.optimize import minimize
+
+from iqm.benchmarks.utils import perform_backend_transpilation, reduce_to_active_qubits, set_coupling_map
+from iqm.qiskit_iqm import transpile_to_IQM
 from iqm.qiskit_iqm.fake_backends.fake_apollo import IQMFakeApollo
-from iqm.benchmarks.utils import perform_backend_transpilation, set_coupling_map, reduce_to_active_qubits
+from mGST.additional_fns import multikron
 
 
 class TestPerformBackendTranspilation(unittest.TestCase):
@@ -64,6 +68,63 @@ class TestPerformBackendTranspilation(unittest.TestCase):
 
         return len(active_qubits)
 
+    def equiv_up_to_local_z(self, op1: "Operator", op2: "Operator", atol: float = 1e-6) -> bool:
+        """
+        Check if two operators are equivalent up to local Z rotations and global phase at the beginning
+        or end of the circuit.
+
+        Args:
+            op1: First Qiskit Operator object to compare
+            op2: Second Qiskit Operator object to compare
+            atol: Absolute tolerance for numerical comparison
+
+        Returns:
+            bool: True if operators are equivalent up to local Z rotations
+        """
+
+        # First check dimensions match
+        if op1.dim != op2.dim:
+            return False
+
+        def u_rz(u: np.ndarray, angles: np.ndarray) -> np.ndarray:
+            """
+            Apply before-and-after local Z rotations and global phase to a unitary matrix.
+
+            Args:
+                u: Input unitary matrix
+                angles: Rotation angles (first is global phase, others for local Z rotations)
+
+            Returns:
+                np.ndarray: Modified unitary matrix
+            """
+            rz_l = multikron(np.array([np.array([[1, 0], [0, np.exp(1j * angle)]]) for angle in angles[2::2]]))
+            rz_r = multikron(np.array([np.array([[1, 0], [0, np.exp(1j * angle)]]) for angle in angles[1::2]]))
+            return np.exp(1j * angles[0]) * rz_l @ u @ rz_r
+
+        def dist_up_to_rz(angles: np.ndarray, u1: np.ndarray, u2: np.ndarray) -> float:
+            """
+            Compute the distance between two unitary matrices up to local Z rotations.
+
+            Args:
+                angles: Rotation angles to optimize
+                u1: First unitary matrix
+                u2: Second unitary matrix
+
+            Returns:
+                float: Frobenius norm of the difference between the modified matrices
+            """
+            u1_rz = u_rz(u1, angles)
+            return np.linalg.norm(u1_rz - u2, ord='fro')
+
+        res = minimize(
+            dist_up_to_rz,
+            x0=np.ones(2 * int(np.log2(op1.dim[0])) + 1),
+            args=(op1.to_matrix(), op2.to_matrix()),
+            method='L-BFGS-B',
+        )
+
+        return res.fun < atol
+
     def test_basic_transpilation(self):
         """Test basic transpilation functionality."""
 
@@ -73,7 +134,7 @@ class TestPerformBackendTranspilation(unittest.TestCase):
             self.qubit_layout,
             self.coupling_map,
             qiskit_optim_level=1,
-            optimize_sqg=True,
+            optimize_sqg=False,
         )
 
         # Verify we get the same number of circuits back
@@ -99,8 +160,9 @@ class TestPerformBackendTranspilation(unittest.TestCase):
                 reduced_qc_transp.remove_final_measurements()
                 op = Operator(reduced_qc)
                 op_transp = Operator(reduced_qc_transp)
-                fidelity = np.abs(op.equiv(op_transp))
-                self.assertGreaterEqual(fidelity, 0.9999)
+                self.assertTrue(
+                    op.equiv(op_transp), f"Circuit {i} failed unitary equivalence check after transpilation"
+                )
 
     def test_transpilation_with_sqg_optimization(self):
         """Test with and without single-qubit gate optimization."""
@@ -126,7 +188,8 @@ class TestPerformBackendTranspilation(unittest.TestCase):
 
         # The circuits should be functionally equivalent
         for i in range(len(self.test_circuits)):
-            # For small circuits we can check unitary equivalence
+            # For small circuits we can check unitary equivalence, this time up to global phase and local Z rotations
+            # since those are ignored in the single qubit gate optimization
             if self.test_circuits[i].num_qubits <= 3:
                 reduced_qc_with = reduce_to_active_qubits(transpiled_with_opt[i])
                 reduced_qc_with.remove_final_measurements()
@@ -134,8 +197,8 @@ class TestPerformBackendTranspilation(unittest.TestCase):
                 reduced_qc_without.remove_final_measurements()
                 op_with = Operator(reduced_qc_with)
                 op_without = Operator(reduced_qc_without)
-                fidelity = np.abs(op_with.equiv(op_without))
-                self.assertGreaterEqual(fidelity, 0.9999)
+                equiv_rz = self.equiv_up_to_local_z(op_with, op_without)
+                self.assertTrue(equiv_rz, f"Circuit {i} failed unitary equivalence check after transpilation")
 
     def test_transpilation_with_parameter_binding(self):
         """Test transpilation with parameter binding."""
@@ -160,7 +223,7 @@ class TestPerformBackendTranspilation(unittest.TestCase):
             initial_layout=self.qubit_layout[:2],  # Only need 2 qubits
             coupling_map=self.coupling_map,
             optimization_level=1,
-            seed_transpiler=42
+            seed_transpiler=42,
         )
 
         # Check that the output circuit has no free parameters

{iqm_benchmarks-2.39 → iqm_benchmarks-2.40}/tests/unit/test_submit_execute.py

@@ -1,12 +1,11 @@
 import unittest
-from unittest.mock import Mock, patch, call
+from unittest.mock import Mock, call, patch
 
+from iqm.benchmarks.utils import submit_execute
+from iqm.iqm_client.models import CircuitCompilationOptions
 from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 from iqm.qiskit_iqm.iqm_job import IQMJob
-from iqm.iqm_client.models import CircuitCompilationOptions
-from iqm.benchmarks.utils import submit_execute
-
 
 
 class TestSubmitExecute(unittest.TestCase):
@@ -53,7 +52,7 @@ class TestSubmitExecute(unittest.TestCase):
     @patch('iqm.benchmarks.utils.qcvv_logger')
     def test_submit_execute_no_restrictions(self, mock_logger):
         """Test with no batch size restrictions."""
-        jobs,_ = submit_execute(self.sorted_circuits, self.mock_backend, shots=1000)
+        jobs, _ = submit_execute(self.sorted_circuits, self.mock_backend, shots=1000)
 
         # Should return after first batch
         self.assertEqual(len(jobs), 2)
@@ -61,21 +60,14 @@ class TestSubmitExecute(unittest.TestCase):
         # Check that backend.run was called with each circuit list
         expected_calls = []
         for key in self.sorted_circuits.keys():
-            expected_calls.append(call(
-                self.sorted_circuits[key], shots=1000, calibration_set_id=None
-            ))
+            expected_calls.append(call(self.sorted_circuits[key], shots=1000, calibration_set_id=None))
         self.mock_backend.run.assert_has_calls(expected_calls, any_order=True)
 
     @patch('iqm.benchmarks.utils.qcvv_logger')
     def test_submit_execute_max_circuits(self, mock_logger):
         """Test with max_circuits_per_batch restriction."""
 
-        jobs, _ = submit_execute(
-            self.sorted_circuits,
-            self.mock_backend,
-            shots=1000,
-            max_circuits_per_batch=2
-        )
+        jobs, _ = submit_execute(self.sorted_circuits, self.mock_backend, shots=1000, max_circuits_per_batch=2)
 
         # Check that backend.run was called with correct batches
         expected_calls = [
@@ -101,12 +93,7 @@ class TestSubmitExecute(unittest.TestCase):
 
         # Each small circuit has 5 operations, each large has 10
         # Set max_gates_per_batch to a value that will test different batch sizes
-        jobs,_ = submit_execute(
-            self.sorted_circuits,
-            self.mock_backend,
-            shots=1000,
-            max_gates_per_batch=15
-        )
+        jobs, _ = submit_execute(self.sorted_circuits, self.mock_backend, shots=1000, max_gates_per_batch=15)
 
         # For large circuits (12 operations each), batches should have 1 circuit per batch
         # For small circuits (5 operations each), batches should have 3 circuits per batch
@@ -117,8 +104,7 @@ class TestSubmitExecute(unittest.TestCase):
         actual_batch_sizes = [len(args[0]) for args, _ in self.mock_backend.run.call_args_list]
 
         # Verify we have the right number of batches
-        self.assertEqual(len(actual_batch_sizes),
-                         len(expected_batch_sizes_large) + len(expected_batch_sizes_small))
+        self.assertEqual(len(actual_batch_sizes), len(expected_batch_sizes_large) + len(expected_batch_sizes_small))
 
         # Verify batch sizes match our expectations
         self.assertEqual(actual_batch_sizes[4:], expected_batch_sizes_large)
@@ -132,12 +118,8 @@ class TestSubmitExecute(unittest.TestCase):
     def test_submit_execute_both_restrictions(self, mock_logger):
         """Test with both max_gates_per_batch and max_circuits_per_batch restrictions."""
 
-        jobs,_ = submit_execute(
-            self.sorted_circuits,
-            self.mock_backend,
-            shots=1000,
-            max_gates_per_batch=15,
-            max_circuits_per_batch=2
+        jobs, _ = submit_execute(
+            self.sorted_circuits, self.mock_backend, shots=1000, max_gates_per_batch=15, max_circuits_per_batch=2
         )
 
         # For large circuits:
@@ -168,5 +150,6 @@ class TestSubmitExecute(unittest.TestCase):
             # Circuits per batch should not exceed max_circuits_per_batch
             self.assertLessEqual(batch_size, 2)
 
+
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()