IN YELLOW- placeholders for graphical additions needed by marketing departments

Case Study: Integrating Classiq With Alice & Bob Logical Qubits Simulator

https://youtu.be/ohPzKZtcCfs?si=HxhMka-PQp6yrfu1 

VIDEO EMBEDDED IN PAGE

For the updated notebook described in the video, visit Classiq Library

1. Introduction and Motivation

The transition from NISQ-era computation to fault-tolerant architectures requires not only new hardware but also new software abstractions.
Logical qubits — qubits encoded using error correction — behave very differently from today’s physical devices. They operate over discrete, non-parametric gate sets and introduce algorithm-dependent noise behaviors that traditional toolchains do not expose.

This case study describes the joint effort between Classiq and Alice & Bob to:

1. Provide a complete workflow from high-level quantum modeling to logical-qubit-aware execution.
2. Expose realistic logical-layer parameters, such as code distance and κ₂/κ₁ ratios (cat-qubit quality).
3. Enable algorithm designers to evaluate performance and cost (depth, T-count, noise sensitivity) ahead of actual logical-qubit hardware.

Figure Placeholder: Classiq × Alice & Bob logos (top banner)

2. Context: Why Logical-Qubit Development Requires New Tools

By their nature, logical qubits introduce constraints highly relevant to algorithm designers:

1. Discrete Gate Sets (Clifford + T)

Logical architectures avoid arbitrary rotations. A gate such as RX(0.1) must be approximated using discrete gates. 

Traditional toolchains only apply Solovay–Kitaev or other generic compilation methods.
For example, using standard SK decompositions:

• RX(0.1) → Depth 1 on a standard physical-qubit backend
• The same gate → Depth 170 on Alice & Bob logical backend (default)
• With stricter precision → Depth 1000+

2. Error-Correction Parameters Are Algorithm-Specific

Logical qubit quality depends on:

• Distance (size of repetition code)
• κ₂/κ₁ (relative rates of two-photon stabilization vs. single-photon loss)
• Average number of photons (affects bit-flip vs. phase-flip behavior)

These parameters create tradeoffs not present in physical systems.
Increasing distance can increase circuit-level error, not because we're operating above threshold, but because we're changing the dominant type of error.

• For example, increasing distance improves phase-flips but worsens bit-flips, so if you're in a regime where your phase-flip is already low enough, you should NOT use a higher distance, and this is what we see in our examples.

This is really specific to cat qubits, because with other types of qubits, distance makes both types of errors go down, so as long as you're below threshold, you're "just" wasting qubits if you increase distance more than necessary.

This behavior is clearly evident in the parameter sweeps for the swap test that we are about to examine.

3. Integration Architecture

Classiq supports Alice & Bob’s logical backends:

• LOGICAL_EARLY: Higher logical error rates (10⁻³–10⁻⁴)
• LOGICAL_TARGET: Parameters suitable for large-scale workloads (e.g., Shor-like circuits)
• LOGICAL_NOISELESS: Noiseless backend featuring the same native gate set as the other logical backends, but without a noise model. It is faster and designed to separate errors stemming from transpilation from errors stemming from device noise

Users can override backend parameters (distance, κ₂/κ₁, photon count) to run controlled studies.

Once the backend is chosen, Classiq converts high-level models into circuits compatible with Alice & Bob’s logical architecture. Including:

1. Gate-set rewriting to Clifford+T
2. Noise-aware optimizations
3. Depth/T-count estimation
4. Support for future decomposition methods

Improved Decomposition Method

We are currently developing a more efficient Clifford+T approximation procedure that outperforms generic Solovay–Kitaev, and builds upon the specialized techniques discussed here, resulting in:

• Lower T-count
• Reduced depth scaling
• Tunable precision guarantees

Within a complete quantum circuit, our method performs an optimal decomposition of arbitrary unitary gates into a minimal number of Pauli rotations. Then, the optimal subset of these rotations are selected on which to perform magnitude approximation taking into account commutation relations between these and neighboring gates. The remaining rotations are handled through diagonal approximation.

4. Technical Walkthrough: From High-Level Model to Logical Execution

Link to the notebook: https://github.com/Classiq/classiq-library/blob/main/community/basic_examples/logical_qubits/logical_qubits_by_alice_and_bob.ipynb  

Users express intent using Classiq’s modeling language (e.g., SWAP test):

@qfunc
def main(test: Output[QBit]):
    state1 = QArray()
    state2 = QArray()
    prepare_amplitudes(amps1, 0.0, state1)
    prepare_amplitudes(amps2, 0.0, state2)
    swap_test(state1, state2, test)

Once the model is written, the user selects the backend with the required parameters:

backend_preferences = AliceBobBackendPreferences(
    backend_name=AliceBobBackendNames.LOGICAL_TARGET,
    kappa_1=100,
    kappa_2=1e5,
    distance=7,
    average_nb_photons=15,
)

After synthesizing the circuit Classiq produces:

• Clifford + T circuits
• With explicit T-count, depth, and structure
• With optional Solovay–Kitaev parameters (or future improved decomposition)

The emulator lets developers study:

• Error rate as a function of (distance, κ₂/κ₁, photon count)
• Behavior under extremely low-noise vs. high-noise regimes
• The point at which error correction transitions from beneficial to harmful

In the notebook, thousands of runs across parameter combinations reveal:

• Threshold behavior at κ₂/κ₁ ≈ 10⁴
• Photon count <7 → unacceptable bit-flip rates regardless of distance
• Distance improves fidelity only up to a certain point
• Beyond a threshold, increased distance increases logical error
  
  

5. Key Technical Insights From the Collaboration

1. Logical circuits impose fundamentally different cost models

• A single rotation becomes a large Clifford+T block.
• Depth grows logarithmically with desired precision.
• T-count becomes a primary performance metric.

2. Logical noise models matter to algorithm designers

Developers must consider:

• Do I need fewer logical qubits but higher fidelity?
• Is my workload dominated by bit-flip or phase-flip vulnerabilities?
• What photon count makes sense for my application?
• What distance yields optimal tradeoffs for my algorithm?

3. Error-correction thresholds shape algorithm feasibility‍

When the underlying physical quality (κ₂/κ₁) is below the threshold,increasing distance makes the logical error worse — a non-intuitive behavior that algorithm teams need to understand early.