gala-hardware-backends

Files (1)

• SKILL.md

SKILL.md (first lines)

## Task

$ARGUMENTS

## Overview

Gala programs are **backend-agnostic**. You write once, run anywhere — simulator, noisy simulator, or real hardware (IBM, IonQ, Quantinuum, Braket, etc.) via QIR.

## Backend Model

```gala
fn main() {
    // Backend is a capability value — checked at compile time
    let backend = backend.simulator()              // State-vector
    // let backend = backend.noisy(depolarizing(0.01))  // Noisy sim
    // let backend = backend.hardware("ionq.aria")      // Real hardware
    // let backend = backend.hardware("ibm.osprey")     // IBM
    
    let result = run(classify, on: backend, shots: 1000)
}
```

**Key:** Same program, one-line backend change.

## Available Backends

| Backend | Command | Profile | Use Case |
|---------|---------|---------|----------|
| Simulator | `backend.simulator()` | Base | Development, exact results |
| Noisy Sim | `backend.noisy(model)` | Base | Error-aware development |
| IonQ Aria | `backend.hardware("ionq.aria")` | Adaptive | Trapped ion, all-to-all |
| Quantinuum | `backend.hardware("quantinuum.h1")` | Adaptive | Trapped ion, mid-circuit |
| IBM Osprey | `backend.hardware("ibm.osprey")` | Base/Adaptive | Superconducting |
| AWS Braket | `backend.hardware("braket.rigetti")` | Base | Multiple vendors |

## Capability Checking (Compile-Time)

The compiler **rejects** programs that don't fit the backend:

```gala
// This requires mid-circuit measurement → needs Adaptive profile
fn adaptive_algo() -> Measured<Bool> prob {
    let q = qubit()
    h(q)
    let m = measure(q)  // Mid-circuit!
    if m { x(q) }       // Feedback
    measure(q)
}

// Compile for base-profile backend → ERROR
let backend = backend.hardware("ibm.osprey")  // Base profile only
run(adaptive_algo, on: backend)  // E0601: capability mismatch
```

**Error:**
```
error[E0601]: backend capability mismatch
  ┌─ src/main.gala:10:5
10 │     run(adaptive_algo, on: backend)
   │     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   = help: program requires Adaptive profile (mid-circuit measurement)
           but backend 'ibm.osprey' only supports Base profile.
           Use a backend with mid-circuit support (ionq.aria, quantinuum.h1)
           or restructure to defer measurement.
```

## QIR Emission

```bash
# Emit QIR (LLVM IR) for inspection or manual submission
gala build src/main.gala --emit qir

# Output: main.ll (LLVM IR text) or main.bc (bitcode)
```

### Profile Selection
- **Base profile** — straight-line circuits, terminal measurement
- **Adaptive profile** — mid-circuit measurement, feedback, `if measure(q) { ... }`

Compiler chooses automatically based on program structure.

## Running on Hardware

### Prerequisites
```bash
# Configure credentials (once)
gala config set ionq.api_key YOUR_KEY
gala config set ibm.token YOUR_TOKEN
# Or use environment variables
export IONQ_API_KEY=...
export IBM_QUANTUM_TOKEN=...
```

### Submit Job
```bash
# Simulator (local, instant)
gala run src/main.gala --backend simulator --shots 1000

# Hardware (queued, async)
gala run src/main.gala --backend hardware:ionq.aria --shots 1000

# Poll for results
gala run src/main.gala --backend hardware:ionq.aria --shots 1000 --wait

# Or get job ID and check later
gala run src/main.gala --backend hardware:ionq.aria --shots 1000 --async
# Returns job ID
gala job status <job-id>
gala job results <job-id>
```

## Noise-Aware Development

```gala
import gala.noise.{ depolarizing, amplitude_damping, NoiseModel }

// Define noise model
let noise = depolarizing(0.01)  // 1% depolarizing

From gala-pl/gala, Apache-2.0.

More from gala-pl/gala