[QI2-1322] Clean up for hybrid

examples/hqca_circuit.py

@@ -1,22 +1,19 @@
-from pathlib import Path
 from typing import Any, Dict, List
 
+from opensquirrel.circuit_builder import CircuitBuilder
 from opensquirrel.ir import Bit, Qubit
-
-from quantuminspire.sdk.models.circuit import Circuit
-from quantuminspire.sdk.models.hybrid_algorithm import HybridAlgorithm
-from quantuminspire.util.api.local_backend import LocalBackend
-from quantuminspire.util.api.quantum_interface import QuantumInterface
+from opensquirrel.writer import writer
+from qi2_shared.hybrid.quantum_interface import QuantumInterface
 
 
 def generate_circuit() -> str:
-    with Circuit(platform_name="spin-2", program_name="prgm1", number_of_qubits=2) as circuit:
-        circuit.ir.H(Qubit(0))
-        circuit.ir.CNOT(Qubit(0), Qubit(1))
-        circuit.ir.measure(Qubit(0), Bit(0))
-        circuit.ir.measure(Qubit(1), Bit(1))
+    builder = CircuitBuilder(qubit_register_size=2, bit_register_size=2)
+    builder.H(Qubit(0))
+    builder.CNOT(Qubit(0), Qubit(1))
+    builder.measure(Qubit(0), Bit(0))
+    builder.measure(Qubit(1), Bit(1))
 
-    return circuit.content
+    return writer.circuit_to_string(builder.to_circuit())
 
 
 def execute(qi: QuantumInterface) -> None:
@@ -58,17 +55,3 @@ def finalize(list_of_measurements: Dict[int, List[Any]]) -> Dict[str, Any]:
     """
     print(list_of_measurements)
     return {"results": list_of_measurements}
-
-
-if __name__ == "__main__":
-    # Run the individual steps for debugging
-    print("=== Circuit ===\n", generate_circuit())
-
-    algorithm = HybridAlgorithm("test", "test")
-    algorithm.read_file(Path(__file__))
-
-    local_backend = LocalBackend()
-    job_id = local_backend.run(algorithm, 0)
-    results = local_backend.get_results(job_id)
-
-    print("=== Execute ===\n", results)

examples/qaoa.py

@@ -9,11 +9,11 @@
 import networkx as nx
 import numpy as np
 from networkx import Graph
+from opensquirrel.circuit_builder import CircuitBuilder
 from opensquirrel.ir import Bit, Float, Qubit
+from opensquirrel.writer import writer
 from scipy.optimize import Bounds, minimize
 
-from quantuminspire.sdk.models.circuit import Circuit
-
 MATRIX = np.matrix([[0, 1], [1, 0]])
 GRAPH = nx.from_numpy_array(MATRIX)
 positions = nx.circular_layout(GRAPH)
@@ -74,23 +74,23 @@ def qaoa_circuit(graph: Graph, beta: np.ndarray, gamma: np.ndarray) -> str:
     Returns:
         cQASM string representing the quantum circuit used to compute the energies in the QAOA algorithm.
     """
-    with Circuit(platform_name="spin-2", program_name="qaoa", number_of_qubits=graph.number_of_nodes()) as circuit:
-        for i in graph.nodes:
-            circuit.ir.H(Qubit(i))
+    builder = CircuitBuilder(qubit_register_size=2, bit_register_size=2)
+    for i in graph.nodes:
+        builder.H(Qubit(i))
 
-        for i in range(P):
-            for edge in graph.edges():
-                circuit.ir.CNOT(Qubit(edge[0]), Qubit(edge[1]))
-                circuit.ir.Rz(Qubit(edge[1]), Float(2 * gamma[i]))
-                circuit.ir.CNOT(Qubit(edge[0]), Qubit(edge[1]))
+    for i in range(P):
+        for edge in graph.edges():
+            builder.CNOT(Qubit(edge[0]), Qubit(edge[1]))
+            builder.Rz(Qubit(edge[1]), Float(2 * gamma[i]))
+            builder.CNOT(Qubit(edge[0]), Qubit(edge[1]))
 
-            for j in graph.nodes():
-                circuit.ir.Rx(Qubit(j), Float(2 * beta[i]))
+        for j in graph.nodes():
+            builder.Rx(Qubit(j), Float(2 * beta[i]))
 
-        for i in graph.nodes:
-            circuit.ir.measure(Qubit(i), Bit(i))
+    for i in graph.nodes:
+        builder.measure(Qubit(i), Bit(i))
 
-    return circuit.content
+    return writer.circuit_to_string(builder.to_circuit())
 
 
 def generate_objective_function(qi, graph) -> Callable:

examples/unfair_dice.py

@@ -23,12 +23,12 @@
 from typing import Any, Dict, List
 
 import numpy as np
+from opensquirrel.circuit_builder import CircuitBuilder
 from opensquirrel.ir import Bit, Float, Qubit
+from opensquirrel.writer import writer
+from qi2_shared.hybrid.quantum_interface import ExecuteCircuitResult, QuantumInterface
 from qiskit_algorithms.optimizers import SPSA
 
-from quantuminspire.sdk.models.circuit import Circuit
-from quantuminspire.util.api.quantum_interface import ExecuteCircuitResult, QuantumInterface
-
 
 def counts_to_distr(counts: Dict[str, int]) -> dict[int, float]:
     """Convert Qiskit result counts to a dictionary.
@@ -105,7 +105,7 @@ def __call__(self, nfev, parameters, value, update, accepted) -> bool:
 dt = AverageDecreaseTermination(N=35)
 
 
-def U(circuit_ir, q: Qubit, theta: float, phi: float, lamb: float):
+def U(builder: CircuitBuilder, q: Qubit, theta: float, phi: float, lamb: float):
     """McKay decomposition of the U gate.
 
     :param self: circuit object
@@ -115,31 +115,31 @@ def U(circuit_ir, q: Qubit, theta: float, phi: float, lamb: float):
     :param lamb: angle
     :return: circuit object
     """
-    circuit_ir.Rz(q, Float(phi))
-    circuit_ir.Rx(q, Float(-np.pi / 2))
-    circuit_ir.Rz(q, Float(theta))
-    circuit_ir.Rx(q, Float(np.pi / 2))
-    circuit_ir.Rz(q, Float(lamb))
-    return circuit_ir
+    builder.Rz(q, Float(phi))
+    builder.Rx(q, Float(-np.pi / 2))
+    builder.Rz(q, Float(theta))
+    builder.Rx(q, Float(np.pi / 2))
+    builder.Rz(q, Float(lamb))
+    return builder
 
 
-def generate_ansatz(params: List[Any]):
-    with Circuit(platform_name="spin-2", program_name="prgm1", number_of_qubits=2) as circuit:
-        U(circuit.ir, Qubit(0), *params[0:3])
-        U(circuit.ir, Qubit(1), *params[3:6])
-        circuit.ir.CZ(Qubit(0), Qubit(1))
-        U(circuit.ir, Qubit(0), *params[6:9])
-        U(circuit.ir, Qubit(1), *params[9:12])
-        for ii in range(number_of_qubits):
-            circuit.ir.measure(Qubit(ii), Bit(ii))
+def generate_ansatz(params: List[Any]) -> str:
+    builder = CircuitBuilder(qubit_register_size=number_of_qubits, bit_register_size=number_of_qubits)
+    U(builder, Qubit(0), *params[0:3])
+    U(builder, Qubit(1), *params[3:6])
+    builder.CZ(Qubit(0), Qubit(1))
+    U(builder, Qubit(0), *params[6:9])
+    U(builder, Qubit(1), *params[9:12])
+    for ii in range(number_of_qubits):
+        builder.measure(Qubit(ii), Bit(ii))
 
-    return circuit
+    return writer.circuit_to_string(builder.to_circuit())
 
 
 def objective_function(params: List[Any], qi: QuantumInterface, target_distribution: Dict[int, float], nshots=None):
     """Compares the output distribution of our circuit with parameters `params` to the target distribution."""
-    qc = generate_ansatz(params)
-    execute_result = qi.execute_circuit(qc.content, nshots)
+    cqasm = generate_ansatz(params)
+    execute_result = qi.execute_circuit(cqasm, nshots)
     # Convert the result to a dictionary with probabilities
     output_distr = counts_to_distr(execute_result.results)
     # Calculate the cost as the distance between the output

pyproject.toml

@@ -24,7 +24,7 @@ qi = "quantuminspire.cli.command_list:app"
 python = "^3.9"
 typer = {extras = ["all"], version = "^0.15.1"}
 pydantic = "^2.10.5"
-qi-compute-api-client = "^0.42.0"
+qi-compute-api-client = "^0.44.0"
 qxelarator = {version = "^0.7.2", optional = true}
 pydantic-settings = "^2.7.1"
 qiskit = "1.0.2"