gala-testing

Files (1)

• SKILL.md

SKILL.md (first lines)

## Task

$ARGUMENTS

## Overview

Testing in Gala is a **language feature**. The compiler provides quantum-aware property testing that verifies physical invariants, not just example assertions.

## Property Testing (Signature Feature)

Add attributes to functions to enable automatic property verification:

```gala
#[property(unitary)]        // f†f = I (for quantum functions)
#[property(reversible)]     // adjoint(f) ∘ f = identity
#[property(uncomputes)]     // Ancillae return to |0⟩
#[property(grad_matches)]   // grad ≈ finite difference
#[property(effect_honesty)] // quantum fn has no measurement
```

### Example: Testing a Circuit

```gala
// src/adder.gala
#[property(unitary)]
#[property(reversible)]
#[property(uncomputes)]
fn ripple_adder(a: Qubits<4>, b: Qubits<4>) -> (Qubits<4>, Qubits<4>) quantum {
    // ... adder circuit with ancilla ...
    (a, b)  // ancilla auto-uncomputed
}

// Run property tests
gala test src/adder.gala --property unitary
gala test src/adder.gala --property reversible
gala test src/adder.gala --property uncomputes
```

### How It Works

1. **Compiler generates** randomized input states
2. **Simulator executes** circuit and properties
3. **Property checker** verifies invariant
4. **On failure:** shrinks to minimal counterexample

### Output
```
PASS: property(unitary) on ripple_adder
  Tested 100 random states, max ||f†f - I|| = 2.3e-15

FAIL: property(uncomputes) on bad_adder
  Counterexample: input |1010⟩|0000⟩
  Ancilla q4: |0.001⟩ + |0.999⟩  (should be |0⟩)
  Shrinking...
  Minimal: missing adjoint on q4
```

## Property Types

| Property | Checks | Applicable To |
|----------|--------|---------------|
| `unitary` | Matrix is unitary | `quantum` functions |
| `reversible` | `adjoint(f)(f(x)) ≈ x` | `quantum` functions |
| `uncomputes` | Ancillae ≈ \|0⟩ at scope exit | Functions with ancilla |
| `grad_matches` | `grad(f) ≈ finite_diff(f)` | Hybrid functions with `grad` |
| `effect_honesty` | No `measure` in `quantum` | `quantum` functions |

## Unit Testing

### Classical Pure Functions
```gala
// src/math.gala
fn add(a: Int, b: Int) -> Int pure { a + b }
fn mul(a: Int, b: Int) -> Int pure { a * b }

// Tests in same file or test/ directory
#[test]
fn test_add() {
    assert(add(2, 3) == 5)
    assert(add(-1, 1) == 0)
}

#[test]
fn test_mul() {
    assert(mul(3, 4) == 12)
}
```

Run: `gala test src/math.gala`

### Quantum Functions (with simulator)
```gala
#[test]
fn test_bell_pair() {
    let (a, b) = bell()
    let m1 = measure(a)
    let m2 = measure(b)
    // Perfect correlation
    assert(m1 == m2)  // With enough shots
}

// Run with shots
gala test src/bell_test.gala --shots 1000
```

## Conformance Testing

Gala includes a **conformance suite** (`tests/conformance/`) that defines expected language behavior. You can run it on your programs:

```bash
# Run full conformance suite
gala test --conformance

# Run specific category
gala test --conformance linearity
gala test --conformance effects
gala test --conformance uncompute
```

From gala-pl/gala, Apache-2.0.

More from gala-pl/gala