The qBraid-SDK transpiler allows converting quantum programs from one type to another, for any two program types for which a “conversion path” exists. Registered program types are interconnected via a directed graph, where each program type is represented as a node and supported conversions as edges. The breadth, depth, and connectivity of this ConversionGraph can be customized by the user.

API Reference: qbraid.transpiler

​
Conversion Graph

To view what conversions are available, you can plot the ConversionGraph:

from qbraid.transpiler import ConversionGraph

graph = ConversionGraph()

len(graph.nodes()) # 10
len(graph.edges()) # 25

graph.plot(legend=True)

Gray arrows denote conversions implemented and managed by qBraid. Red arrows represent conversions implemented by external packages or extensions. These are automatically incorporated into the conversion graph upon installing the specified ‘extra’.

You can use the native conversions supported by qBraid, or define your own custom nodes and/or edges. For example:

from unittest.mock import Mock

from qbraid.programs import register_program_type
from qbraid.transpiler import Conversion

# replace with any program type
register_program_type(Mock, alias="mock")

# replace with your custom conversion function
example_qasm3_to_mock_func = lambda x: x

conversion = Conversion("qasm3", "mock", example_qasm3_to_mock_func)

graph.add_conversion(conversion)

# using a seed is helpful to ensure reproducibility
graph.plot(seed=20, k=3, legend=True)

Blue arrows indicate conversions added by the user during their current session.

Check if a conversion is supported between two given program types, and if so, what “conversion path(s)” would be used:

>>> graph.has_path("qiskit", "braket")
True
>>> for p in graph.all_paths("qiskit", "braket"): print(p)
qiskit -> braket
qiskit -> qasm3 -> braket
qiskit -> qasm2 -> qasm3 -> braket
qiskit -> qasm2 -> pytket -> braket
qiskit -> qasm2 -> cirq -> braket
>>> graph.shortest_path("qiskit", "braket")
qiskit -> braket

Scope the conversions available to the transpiler by specifying your own conversions list:

from qbraid.transpiler import ConversionGraph, Conversion
from qbraid.transpiler.conversions.qiskit import qiskit_to_braket

conv = Conversion("qiskit", "braket", qiskit_to_braket)
graph = ConversionGraph(conversions=[conv])

graph.all_paths("qiskit", "braket")
# ["qiskit -> qasm3 -> braket"]

​
Conversion Scheme

The ConversionScheme data class details information about conversion configurations, such as numbers of nodes and edges, as well as max depth.

from qbraid.transpiler import ConversionGraph
from qbraid.transpiler.scheme import ConversionScheme

scheme = ConversionScheme(max_path_attempts=3, max_path_depth=None)

custom_graph = ConversionGraph(...)
scheme.update_scheme(conversion_graph=custom_graph)

scheme.to_dict()

​
Transpile

Using the qbraid.transpiler.transpile method, simply pass in the name of the target package from one of qbraid.programs.QPROGRAM_ALIASES. For example, use input "cirq" to return a cirq.Circuit:

from qiskit import QuantumCircuit

def bell():
    circuit = QuantumCircuit(2)
    circuit.h(0)
    circuit.cx(0,1)
    return circuit

qiskit_circuit = bell()

from qbraid.transpiler import transpile

cirq_circuit = transpile(qiskit_circuit, "cirq")
print(cirq_circuit)

# q_0: ───H───@───
#             │
# q_1: ───────X───

This time, using the same origin circuit, we’ll input "pyquil" to return a pyquil.quil.Program:

pyquil_program = transpile(qiskit_circuit, "pyquil")
print(pyquil_program)

# H 0
# CNOT 0 1

See also:

  • Transpiler Demo Notebook: General Usage

  • Transpiler Demo Notebook: Custom Conversions

    • InterfaceTransforms