TLDR: A research paper proposes using Large Language Models (LLMs) to automatically translate quantum programs between different Quantum Software Development Kits (QSDKs) like Qiskit and Cirq. This approach aims to overcome the limitations of traditional rule-based transpilers, offering a flexible and scalable solution for quantum software interoperability. Preliminary experiments show LLMs like LLaMA 3 and GPT-4o can effectively perform this transpilation, especially with one-shot prompting.
Quantum computing is a rapidly evolving field, but its development is often fragmented due to the existence of various Software Development Kits (SDKs), known as Quantum SDKs or QSDKs. Popular examples include Qiskit, Cirq, and PennyLane. While this diversity offers flexibility, it also creates significant hurdles for developers trying to ensure their quantum programs can run across different platforms. This challenge is known as interoperability, and it’s crucial for building robust hybrid quantum-classical software systems.
Traditionally, converting quantum code from one QSDK to another relies on rule-based transpilers. These tools are designed with specific, rigid mappings between the source and destination code. However, designing and maintaining these rule-based systems is a time-consuming process that demands deep expertise in both the source and target QSDKs. Any change in a QSDK’s syntax or features requires extensive manual updates to the transpiler, making it an inflexible and costly solution.
A New Approach: LLMs as Quantum Code Transpilers
A recent study proposes a novel solution to this problem: leveraging Large Language Models (LLMs) as flexible and automated quantum code transpilers. LLMs, which are trained on vast amounts of text and code, possess remarkable capabilities in understanding code structure, semantics, and intent. This allows them to generate code in a desired target language without needing explicit, manually defined transformation rules. The researchers position LLMs as “programming language-agnostic transpilers” capable of converting quantum programs while preserving their original functionality.
The core idea is to use an LLM to translate quantum code written in one QSDK (e.g., Qiskit) into an equivalent program in another QSDK (e.g., Cirq). This eliminates the need for rigid, rule-based systems and offers a scalable path towards quantum software portability. The proposed workflow involves three key steps:
- Input Specification: The quantum program from the source QSDK is parsed and formatted for the LLM.
- Prompting: A carefully designed prompt guides the LLM, instructing it on the transpilation objective (e.g., “Convert the following Qiskit code into its equivalent in Cirq.”) and providing mapping instructions or examples.
- Code Transpilation: The LLM then generates the corresponding code in the target QSDK.
Preliminary Findings and Model Performance
In their initial experiments, the researchers tested LLaMA 3 (8B), GPT-2, and GPT-4o as LLM-based transpilers. Their goal was to convert Qiskit quantum programs into functionally equivalent Cirq programs. The Qiskit code used for testing involved creating a two-qubit circuit, applying a Hadamard gate, a CNOT gate to entangle qubits, and then measuring them to form a Bell state.
To evaluate the quality of the generated Cirq code, a custom Code Quality Metric was defined. This metric rewards the use of expected Cirq patterns (like circuit creation, qubit initialization, gate operations, and measurements) and penalizes compiler warnings and errors. The score ranges from 0.0 to 1.0.
The results showed varying performance:
- LLaMA 3: In a zero-shot setting (without examples), it generated non-compilable Cirq code, achieving a score of 0.78-1 due to missing measurement operations. However, with one-shot prompting (providing an example), it achieved a perfect score of 1.
- GPT-2: This model failed to produce meaningful transpilation results in both zero-shot and one-shot scenarios, indicating a lack of domain-specific knowledge.
- GPT-4o: Showed variability in its output. In zero-shot, scores ranged from 0.52-1, often missing basic gates or measurement operations, or including unused imports. With one-shot prompting, it also achieved a perfect score of 1. The variability in GPT-4o’s output was attributed to its high degree of creativity, capable of generating diverse valid outputs.
These preliminary findings suggest that LLMs, particularly when guided with specific examples (one-shot prompting), can effectively transpile quantum code between different QSDKs. This work represents a significant step towards enabling intelligent, general-purpose transpilation in the quantum computing ecosystem. For more details, you can refer to the original research paper: LLM-Powered Quantum Code Transpilation.
Also Read:
- QSpark: Enhancing Qiskit Code Generation with Advanced AI
- Navigating Quantum Machine Learning with Phase-Space Maps
Future Directions
The researchers plan to enhance the contextual accuracy and reliability of the transpiled code by integrating a Retrieval-Augmented Generation (RAG) pipeline. They also intend to use established metrics like Transpilation Coverage for more precise evaluation and to extend the transpilation capabilities to support more advanced quantum features.
