Transpiling quantum circuits by a transformers-based algorithm

This paper presents a transformer-based algorithm that efficiently transpiles quantum circuits from QASM to IonQ's native gate sets with over 99.98% accuracy for up to five qubits, demonstrating polynomial scaling complexity suitable for training on high-performance computing infrastructures.

The Gist

Imagine you have a very complex recipe written in Italian (let's say, for a specific type of pasta). You want to cook this exact same dish, but your kitchen only has ingredients and tools that work with Japanese cooking methods. You can't just serve the Italian recipe to a Japanese chef; the ingredients won't match, and the tools won't work. You need a translator who understands both languages perfectly and can rewrite the recipe so the Japanese chef can cook the exact same dish using only Japanese tools.

This is exactly what the researchers in this paper have done, but instead of cooking, they are dealing with Quantum Computers.

The Problem: Quantum "Dialects"

Quantum computers are like different brands of smartphones.

• IBM's quantum computers speak one "language" (a specific set of instructions called gates).
• IonQ's quantum computers speak a different "language."

If you write a program (a quantum circuit) for IBM, it won't run on IonQ. It's like trying to plug a US charger into a UK socket. You need a Transpiler (a translator) to convert the code so it works on the new hardware without changing the actual result of the computation.

The Solution: The "AI Chef" (The Transformer)

Usually, this translation is done by rigid, rule-based software. But the authors asked: What if we used an AI that learns like a human?

They used a Transformer, the same type of AI architecture that powers tools like ChatGPT.

• How it works: Just as a language model learns that "The cat sat on the..." is usually followed by "mat," this model learns that a specific sequence of IBM quantum instructions is usually followed by a specific sequence of IonQ instructions.
• The Magic: Instead of hard-coding rules, the AI "reads" the IBM code and "predicts" the IonQ code, token by token, just like predicting the next word in a sentence.

The Training: Teaching the AI

To teach this AI, the researchers created a massive library of "sentence pairs."

1. They generated thousands of random quantum circuits.
2. They wrote them in IBM's language.
3. They used existing tools to translate them into IonQ's language (the "correct" answer).
4. They fed these pairs to the AI, letting it learn the patterns.

The "Token" Trick:
Quantum code often involves numbers (like rotation angles). Computers don't understand continuous numbers like 3.14159... well in this context. The researchers turned these numbers into "buckets" or "tokens."

• Analogy: Instead of saying "rotate by 3.14159 degrees," the AI learns to say "Rotate by Bucket #64." It's like rounding off a recipe to "a pinch of salt" rather than "0.004 grams," making it easier for the AI to memorize.

The Results: A Near-Perfect Translator

The results were impressive:

• Accuracy: The AI successfully translated circuits with 99.98% accuracy. It got the "grammar" right almost every time.
• Scale: It worked perfectly for circuits with up to 5 qubits (the quantum equivalent of bits).
• Speed: The complexity of the AI grew in a manageable way (polynomially) as the circuits got bigger. This means we can train even bigger models on supercomputers to handle even more complex tasks.

The Catch: The "Solovay-Kitaev" Bottleneck

The researchers also tried a harder test. They took the IBM code, broke it down into its absolute simplest, most basic building blocks (using a mathematical method called the Solovay-Kitaev algorithm), and then tried to translate it.

• The Problem: Breaking the code down into these tiny blocks made the "sentences" incredibly long.
• The Limit: The AI has a "memory window" (it can only look at 768 words at a time). When the translated sentences got too long, the AI couldn't hold the whole picture in its mind.
• The Result: It worked great for small circuits (1 or 2 qubits) but failed for larger ones because the "sentence" was too long for the AI's short-term memory.

Why This Matters

This paper is a major step forward because it proves that AI can act as a universal translator for quantum computers.

• Before: Translating code was a rigid, manual, and error-prone engineering task.
• Now: We have a flexible, learning system that can adapt to new hardware.

The Big Picture: As we build more different types of quantum computers (some using trapped ions, some using superconducting loops, some using light), we won't need to rewrite our software for every new machine. We can just train a "Transformer" to translate our code on the fly, making the quantum future much more accessible.

In short: They built an AI that speaks "IBM-Quantum" and "IonQ-Quantum" fluently, allowing us to write code once and run it anywhere, with almost zero errors.

Technical Summary

Here is a detailed technical summary of the paper "Transpiling quantum circuits by a transformers-based algorithm" by Banfi et al.

1. Problem Statement

Quantum computing hardware is currently fragmented, with different platforms (e.g., superconducting qubits like IBM, trapped ions like IonQ) utilizing distinct sets of native gates determined by their physical interactions. A circuit written for one platform cannot be executed on another without transpilation—the process of translating a logical quantum circuit into an equivalent sequence of gates native to the target hardware.

Current transpilation methods often rely on heuristic optimization or rule-based compilers, which can struggle with efficiency, noise accumulation, and scalability. The authors propose treating quantum transpilation as a sequence-to-sequence translation task, analogous to natural language processing (NLP), leveraging the Transformer architecture to learn the mapping between different gate vocabularies directly from data.

2. Methodology

The authors developed a Transformer-based model to translate OpenQASM code from IBM's native gate set to IonQ's native gate set. The methodology involves four key stages:

A. Data Preparation and Tokenization

• Dataset Generation: Synthetic datasets were generated using Qiskit, creating pairs of logically equivalent circuits: one expressed in IBM's native gates (rz, sx, x, cx) and the other in IonQ's native gates (rxx, rz, ry, rx).
• Tokenization Strategy: Unlike standard NLP which uses sub-word units, the authors used Regular Expressions (RegEx) to parse the rigid syntax of OpenQASM.
  • Syntax Normalization: Redundant syntactic elements (e.g., brackets in q[1]) were stripped to create atomic tokens (e.g., q1).
  • Angle Discretization: Continuous rotation angles $\theta$ in parametric gates were converted into discrete symbolic tokens. Angles were rounded to two decimal places, normalized modulo $2\pi$, and mapped to integer bins using a grid size$\lambda = 128$. For example, an angle of$\approx \pi$ was mapped to a specific token like PARAM 64.

B. Model Architecture

• Encoder-Decoder Structure: The model uses a standard Transformer encoder-decoder architecture with 6 layers in both stacks.
  • Encoder: Processes the source IBM QASM sequence.
  • Decoder: Generates the target IonQ QASM sequence using cross-attention to align the input context with the output generation.
• Hyperparameters: The model features an embedding dimension of 768, 8 attention heads, and a context window of 768 tokens. The total parameter count is approximately 80.36 million.
• Training Objective: A composite loss function was used:
  $$L = \alpha L_F + \beta L_{CE}$$
  • Cross-Entropy Loss ($L_{CE}$): Ensures syntactic correctness of the generated QASM.
  • Fidelity Loss ($L_F$): Measures the physical correctness by calculating the fidelity between the unitary matrix of the predicted circuit and the reference circuit.
  • Label Smoothing: Applied to prevent overconfidence and improve generalization.

C. Alternative Approach: Solovay-Kitaev Decomposition

The authors also tested a scenario where the input circuit was first decomposed into a universal discrete gate set (e.g., $\{H, T, T^\dagger\}$) using the Solovay-Kitaev algorithm before transpilation. This approach removes continuous parameters but significantly increases circuit depth (sequence length).

3. Key Contributions

1. First Application of Transformers for Quantum Transpilation: The paper demonstrates that Transformer models can effectively learn the complex mapping between distinct quantum hardware gate sets, treating the problem as a language translation task.
2. High Accuracy on Continuous Gates: The model achieved >99.98% accuracy in correctly transpiling circuits with continuous rotation gates for systems up to 5 qubits.
3. Complexity Analysis: The authors derived and empirically validated the scaling laws of the model.
   • For standard parametric circuits, the token count scales linearly with circuit depth and qubit count.
   • For Solovay-Kitaev decomposed circuits, the sequence length scales polynomially ($O(m \log^c(m/\epsilon))$), revealing a bottleneck in fixed-context window architectures.
4. Physics-Informed Training: The integration of a fidelity-based loss term ensures that the model learns not just the syntax of the target language, but also the underlying physical unitary properties of the quantum operations.

4. Results

• Cross-Platform Transpilation (IBM $\to$ IonQ):
  • The model successfully translated circuits for 1 to 5 qubits.
  • Grammar Accuracy: Nearly 100% of generated QASM files were syntactically valid.
  • Fidelity: The transpiled circuits maintained high fidelity with the original unitary operations, converging effectively during training.
  • Perplexity: The model achieved low perplexity (2.4–2.6), indicating high confidence in token prediction.
• Intra-Platform Optimization (IBM Eagle $\to$ IBM Heron):
  • The model successfully adapted to subtle differences between similar IBM backends, demonstrating generalization capabilities.
• Solovay-Kitaev Limitations:
  • When attempting to transpile circuits decomposed via Solovay-Kitaev, the model failed for circuits with 3+ qubits.
  • Cause: The decomposition caused the sequence length to exceed the fixed 768-token context window. This highlighted a hardware constraint where discrete basis compilation requires significantly larger context windows or HPC resources to manage the expanded token count.

5. Significance and Future Outlook

• Automated Compilation: This work establishes a viable path for data-driven quantum compilation, potentially replacing or augmenting traditional heuristic compilers with neural networks that can learn optimal gate sequences directly.
• Scalability: The study proves that Transformer models can handle the complexity of multi-qubit systems (up to 5 qubits) with polynomial scaling, making them suitable for training on High-Performance Computing (HPC) infrastructures.
• Hardware Constraints: The results highlight a critical trade-off: while continuous parameter mapping is efficient, discrete gate decomposition (essential for fault-tolerant quantum computing) creates a "memory wall" due to rapid sequence expansion. Future work must address larger context windows or hierarchical processing to handle fault-tolerant gate sets.
• Generalizability: The approach is hardware-agnostic and can be extended to other quantum platforms (e.g., neutral atoms, photonics) by simply retraining on the respective native gate sets.

In conclusion, the paper successfully demonstrates that Transformers are a powerful tool for quantum circuit transpilation, achieving near-perfect accuracy for continuous gate sets while identifying specific architectural limitations for discrete, fault-tolerant gate decompositions.