gala-noise-modeling

Files (1)

• SKILL.md

SKILL.md (first lines)

## Task

$ARGUMENTS

## Overview

Gala treats **noise models as typed first-class values** (`gala.noise`). This enables compile-time noise-aware development and seamless transition from ideal → noisy simulator → hardware.

## Noise Model Types

```gala
import gala.noise.{ NoiseModel, depolarizing, amplitude_damping, phase_damping, thermal_relaxation, custom }
```

### Built-in Models
```gala
// Single-qubit depolarizing: ρ → (1-p)ρ + p/3 (XρX + YρY + ZρZ)
depolarizing(prob: Float) -> NoiseModel

// Amplitude damping (T1 decay): |1⟩ → |0⟩ with prob γ
amplitude_damping(gamma: Float) -> NoiseModel

// Phase damping (T2 dephasing): off-diagonal decay
phase_damping(gamma: Float) -> NoiseModel

// Combined T1/T2 thermal relaxation
thermal_relaxation(t1: Float, t2: Float, gate_time: Float) -> NoiseModel
```

### Composite Models
```gala
// Per-qubit noise (different per qubit)
let noise = NoiseModel::per_qubit([
    depolarizing(0.001),   // q0
    depolarizing(0.002),   // q1
    amplitude_damping(0.01), // q2
])

// Per-gate noise (different per gate type)
let noise = NoiseModel::per_gate({
    "cx": depolarizing(0.01),
    "rz": phase_damping(0.001),
    "measure": NoiseModel::readout_error(0.02, 0.03),  // P(0|1), P(1|0)
})

// Spatially correlated (crosstalk)
let noise = NoiseModel::correlated([
    (depolarizing(0.001), [0, 1]),  // Correlated on q0,q1
])
```

## Using Noise Models

### Noisy Simulator Backend
```gala
fn main() {
    let noise = depolarizing(0.01)
    let backend = backend.noisy(noise)
    let result = run(algorithm, on: backend, shots: 10000)
}
```

### CLI
```bash
# Depolarizing
gala run src/main.gala --noise depolarizing:0.01 --shots 10000

# Amplitude damping
gala run src/main.gala --noise amplitude_damping:0.05

# From file
gala run src/main.gala --noise-file noise_model.toml
```

### Noise Model File (TOML)
```toml
# noise_model.toml
[global]
depolarizing = 0.001

[per_qubit]
0 = { depolarizing = 0.0005 }
1 = { amplitude_damping = 0.01 }

[per_gate]
"cx" = { depolarizing = 0.01 }
"measure" = { readout_error = [0.02, 0.03] }
```

## Error Mitigation

### Zero-Noise Extrapolation (ZNE)
```gala
import gala.mitigation.{ zne_extrapolate, richardson_extrapolate }

fn mitigate_with_zne(circuit: fn() -> Measured<Bool> prob, noise_scales: [Float]) -> Float {
    // Run at different noise levels (stretch gates)
    let expectations = noise_scales.map(|scale| {
        let scaled_noise = scale_noise(base_noise, scale)
        let backend = backend.noisy(scaled_noise)
        run(circuit, on: backend, shots: 1000).expectation()
    })
    // Extrapolate to zero noise
    richardson_extrapolate(noise_scales, expectations)
}
```

### Readout Error Mitigation
```gala
import gala.mitigation.{ readout_mitigation, calibration_matrix }

// Calibrate once per backend
let cal_matrix = calibration_matrix(backend.hardware("ionq.aria"))

// Apply to results
fn mitigate_readout(raw: Measured<Bool>, cal: Matrix) -> Measured<Bool> {
    readout_mitigation(raw, cal)
}
```

From gala-pl/gala, Apache-2.0.

More from gala-pl/gala