WIP: Improves circuits use on tests

tests/conftest.py

@@ -16,15 +16,16 @@
 import pytest
 
 from qiskit import QuantumCircuit
-from qiskit.circuit.library import QuantumVolume
+from qiskit.circuit.library import QuantumVolume, Permutation, LinearFunction
 from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
+from qiskit.quantum_info import random_clifford, random_pauli
 
 from qiskit_ibm_transpiler.utils import (
     create_random_linear_function,
     random_clifford_from_linear_function,
 )
 
-from tests.utils import create_random_circuit
+from tests.utils import create_random_circuit_with_several_operators
 
 from qiskit_ibm_runtime import QiskitRuntimeService
 
@@ -97,12 +98,43 @@ def permutation_circuit_brisbane(brisbane_backend):
 
 
 @pytest.fixture(scope="module")
-def random_circuit_transpiled(brisbane_coupling_map):
-    circuit = create_random_circuit(27, 4, 2)
-    qiskit_lvl3_transpiler = generate_preset_pass_manager(
-        optimization_level=3, coupling_map=brisbane_coupling_map
-    )
-    return qiskit_lvl3_transpiler.run(circuit)
+def random_circuit_with_several_cliffords_transpiled(brisbane_coupling_map):
+    circuit = create_random_circuit_with_several_operators("Clifford", 27, 4, 2)
+    # qiskit_lvl3_transpiler = generate_preset_pass_manager(
+    #     optimization_level=3, coupling_map=brisbane_coupling_map
+    # )
+    # return qiskit_lvl3_transpiler.run(circuit)
+    return circuit
+
+
+@pytest.fixture(scope="module")
+def random_circuit_with_several_linear_functions_transpiled(brisbane_coupling_map):
+    circuit = create_random_circuit_with_several_operators("LinearFunction", 27, 4, 2)
+    # qiskit_lvl3_transpiler = generate_preset_pass_manager(
+    #     optimization_level=3, coupling_map=brisbane_coupling_map
+    # )
+    # return qiskit_lvl3_transpiler.run(circuit)
+    return circuit
+
+
+@pytest.fixture(scope="module")
+def random_circuit_with_several_permutations_transpiled(brisbane_coupling_map):
+    circuit = create_random_circuit_with_several_operators("Permutation", 27, 4, 2)
+    # qiskit_lvl3_transpiler = generate_preset_pass_manager(
+    #     optimization_level=3, coupling_map=brisbane_coupling_map
+    # )
+    # return qiskit_lvl3_transpiler.run(circuit)
+    return circuit
+
+
+@pytest.fixture(scope="module")
+def random_circuit_with_several_paulis_transpiled(brisbane_coupling_map):
+    circuit = create_random_circuit_with_several_operators("PauliNetwork", 27, 4, 2)
+    # qiskit_lvl3_transpiler = generate_preset_pass_manager(
+    #     optimization_level=3, coupling_map=brisbane_coupling_map
+    # )
+    # return qiskit_lvl3_transpiler.run(circuit)
+    return circuit
 
 
 @pytest.fixture(scope="module")

tests/parametrize_functions.py

@@ -104,14 +104,30 @@ def parametrize_coupling_map_format():
     )
 
 
-def parametrize_collector_pass():
+def parametrize_circuit_collector_pass_and_operator_name():
     return pytest.mark.parametrize(
-        "collector_pass",
+        "circuit, collector_pass, operator_name",
         [
-            (CollectPermutations),
-            (CollectLinearFunctions),
-            (CollectCliffords),
-            (CollectPauliNetworks),
+            (
+                "random_circuit_with_several_permutations_transpiled",
+                CollectPermutations,
+                "permutation",
+            ),
+            (
+                "random_circuit_with_several_linear_functions_transpiled",
+                CollectLinearFunctions,
+                "linear_function",
+            ),
+            (
+                "random_circuit_with_several_cliffords_transpiled",
+                CollectCliffords,
+                "Clifford",
+            ),
+            (
+                "random_circuit_with_several_paulis_transpiled",
+                CollectPauliNetworks,
+                "pauli",
+            ),
         ],
         ids=["permutation", "linear_function", "clifford", "pauli_network"],
     )
@@ -161,17 +177,20 @@ def parametrize_basic_circuit_collector_pass_and_ai_synthesis_pass():
     return pytest.mark.parametrize(
         "circuit, collector_pass, ai_synthesis_pass",
         [
-            # ("basic_swap_circuit", CollectPermutations, AIPermutationSynthesis),
+            (
+                "basic_swap_circuit",
+                CollectPermutations,
+                AIPermutationSynthesis,
+            ),
             ("basic_cnot_circuit", CollectLinearFunctions, AILinearFunctionSynthesis),
             ("basic_cnot_circuit", CollectCliffords, AICliffordSynthesis),
             (
-                "random_circuit_transpiled",
+                "basic_cnot_circuit",
                 CollectPauliNetworks,
                 AIPauliNetworkSynthesis,
             ),
         ],
-        # ids=["permutation", "linear_function", "clifford"],
-        ids=["linear_function", "clifford", "pauli_network"],
+        ids=["permutation", "linear_function", "clifford", "pauli_network"],
     )
 
 

tests/test_ai_routing_pass.py

@@ -110,9 +110,7 @@ def test_ai_cloud_routing_pass_unexisting_url(qv_circ, brisbane_backend_name):
     [(True, PermissionError), (False, TranspilerError)],
     ids=["local_mode", "cloud_mode"],
 )
-def test_ai_routing_pass_wrong_backend(
-    error_type, local_mode, random_circuit_transpiled
-):
+def test_ai_routing_pass_wrong_backend(error_type, local_mode, basic_cnot_circuit):
     with pytest.raises(
         error_type,
         match=r"User doesn\'t have access to the specified backend: \w+",
@@ -122,7 +120,7 @@ def test_ai_routing_pass_wrong_backend(
                 AIRouting(backend_name="wrong_backend", local_mode=local_mode),
             ]
         )
-        ai_routing_pass.run(random_circuit_transpiled)
+        ai_routing_pass.run(basic_cnot_circuit)
 
 
 @pytest.mark.parametrize("optimization_level", [0, 4])

tests/test_ai_synthesis_pass.py

@@ -18,7 +18,10 @@
 
 from qiskit.transpiler import PassManager
 
-from qiskit_ibm_transpiler.ai.collection import CollectPauliNetworks
+from qiskit_ibm_transpiler.ai.collection import (
+    CollectPauliNetworks,
+    CollectPermutations,
+)
 
 from tests.parametrize_functions import (
     parametrize_basic_circuit_collector_pass_and_ai_synthesis_pass,
@@ -154,7 +157,7 @@ def test_ai_cloud_synthesis_wrong_url(
     assert "Keeping the original circuit" in caplog.text
 
 
-# TODO: When using basic_swap_circuit it works, when using random_circuit_transpiled doesn't. Check why
+# TODO: When using basic_swap_circuit it works, when using random_circuit_with_several_cliffords_transpiled doesn't. Check why
 @pytest.mark.disable_monkeypatch
 @parametrize_basic_circuit_collector_pass_and_ai_synthesis_pass()
 def test_ai_cloud_synthesis_unexisting_url(
@@ -184,7 +187,7 @@ def test_ai_cloud_synthesis_unexisting_url(
     assert isinstance(ai_optimized_circuit, QuantumCircuit)
 
 
-@parametrize_basic_circuit_collector_pass_and_ai_synthesis_pass()
+@parametrize_complex_circuit_collector_pass_and_ai_synthesis_pass()
 @parametrize_local_mode()
 def test_ai_synthesis_always_replace_original_circuit(
     circuit,
@@ -232,6 +235,11 @@ def test_ai_synthesis_keep_original_if_better(
     if collector_pass == CollectPauliNetworks and local_mode:
         pytest.skip("Skipping test for pauli network on local mode")
 
+    # FIXME: It looks like when the optimized circuit is worse than the original one, we
+    # return a modified version of the original circuit that come from the permutation collection
+    if collector_pass == CollectPermutations:
+        pytest.skip("Skipping test for permutation until finish FIXME")
+
     original_circuit = request.getfixturevalue(circuit)
 
     custom_ai_synthesis_pass = PassManager(

tests/test_collection_pass.py

@@ -22,23 +22,28 @@
 
 from tests.utils import create_linear_circuit
 from tests.parametrize_functions import (
-    parametrize_collector_pass,
+    parametrize_circuit_collector_pass_and_operator_name,
     parametrize_collectable_gates_collector_pass_operation_name,
     parametrize_collectable_gates_and_collector_pass,
     parametrize_non_collectable_gates_collector_pass_operation_name,
     parametrize_n_qubits,
 )
 
 
-@parametrize_collector_pass()
-def test_collection_pass(random_circuit_transpiled, collector_pass):
-    original_circuit = random_circuit_transpiled
+@parametrize_circuit_collector_pass_and_operator_name()
+def test_collection_pass(circuit, collector_pass, operator_name, request):
+    original_circuit = request.getfixturevalue(circuit)
 
     custom_collector_pass = PassManager([collector_pass()])
-
     collected_circuit = custom_collector_pass.run(original_circuit)
+    collected_circuit_instructions = collected_circuit.data
+    operators_count = 0
+    for circuit_instruction in collected_circuit_instructions:
+        if operator_name in circuit_instruction.name:
+            operators_count = operators_count + 1
 
     assert isinstance(collected_circuit, QuantumCircuit)
+    assert operators_count == 2
 
 
 @parametrize_collectable_gates_collector_pass_operation_name()

tests/test_transpiler_service.py

@@ -83,6 +83,8 @@ def test_qv_backend_routing(optimization_level, ai, qiskit_transpile_options):
     assert isinstance(transpiled_circuit, QuantumCircuit)
 
 
+# FIXME: Code only supports coupling map list format
+# @parametrize_coupling_map_format()
 @pytest.mark.parametrize(
     "coupling_map",
     [

tests/utils.py

@@ -12,24 +12,56 @@
 
 """Functions used on the tests"""
 import numpy as np
+from typing import Callable
 
 from qiskit import QuantumCircuit
-from qiskit.quantum_info import random_clifford
+from qiskit.circuit.library import Permutation, LinearFunction
+from qiskit.quantum_info import random_clifford, random_pauli
 
 
-def create_random_circuit(total_n_ubits, cliffords_n_qubits, clifford_num):
-    circuit = QuantumCircuit(total_n_ubits)
-    nq = cliffords_n_qubits
-    for c in range(clifford_num):
-        qs = np.random.choice(range(circuit.num_qubits), size=nq, replace=False)
+def create_random_circuit_with_several_operators(
+    operator: str,
+    n_qubits_circuit: int,
+    n_qubits_operator: int,
+    n_operator_circuits: int,
+):
+    circuit = QuantumCircuit(n_qubits_circuit)
+    np.random.seed(42)
+    for c in range(n_operator_circuits):
+        qs = np.random.choice(
+            range(n_qubits_circuit), size=n_qubits_operator, replace=False
+        )
+
+        operator_circuit = create_operator_circuit(operator, n_qubits_operator)
         circuit.compose(
-            random_clifford(nq, seed=42).to_circuit(), qubits=qs.tolist(), inplace=True
+            operator_circuit,
+            qubits=qs.tolist(),
+            inplace=True,
         )
         for q in qs:
             circuit.t(q)
+
     return circuit
 
 
+def create_operator_circuit(operator: str, num_qubits: int):
+    match operator:
+        case "Permutation":
+            return Permutation(num_qubits, seed=42)
+        case "LinearFunction":
+            np.random.seed(42)
+            matrix = np.random.randint(2, size=(num_qubits, num_qubits))
+            circuit = QuantumCircuit(num_qubits)
+            circuit.append(LinearFunction(matrix), range(num_qubits))
+            return circuit
+        case "Clifford":
+            return random_clifford(num_qubits, seed=42).to_circuit()
+        case "PauliNetwork":
+            return random_pauli(num_qubits, seed=42)
+        case _:
+            raise ValueError(f"Unsopported operator {operator}")
+
+
 def create_linear_circuit(n_qubits, gates):
     circuit = QuantumCircuit(n_qubits)
     for q in range(n_qubits - 1):