Define, build and run quantum programs.

from bloqade.gemini import GeminiLogicalDevice
device = GeminiLogicalDevice()
# Define a program and submit it to Gemini with 100 shots.
task = device.task(kernel=two_qubit_ghz, shots=100)
results = task.run_async(dry_run=False).result()

from bloqade import analog
program = analog.examples.rabi_pi_half
# Define a program and submit it to Aquila with 100 shots.
task = program.braket.aquila()
result = task.run_async(shots=100).report()

from ppvm import LossyPauliSum
state = LossyPauliSum.new(n_qubits=1, terms=["Z"])
# Define a noisy program and compute expectation values.
state.loss_channel(0, p=0.02)
state.rx(0, theta=0.1)
state.overlap_with_zero()

from ppvm import GeneralizedTableau
tab = GeneralizedTableau(n_qubits=2)
# Define a noisy program with feedforward.
tab.loss_channel(0, p=0.02)
outcome = tab.measure(0)
if outcome == 1:
    tab.x(1)

import tsim
circuit = tsim.Circuit()
# Define a noisy circuit and sample detectors and observables.
# ... Add gates and noise channels
detector_sampler = circuit.compile_detector_sampler()
det_obs_results = detector_sampler.sample(shots=100_000)

from bloqade import lanes

# Define a custom architecture and visualize a compiled move program
arch = lanes.arch.ArchBuilder(...).build()
move_compiler = lanes.transform.PhysicalPipeline(arch_spec=arch)
move_program = move_compiler.emit(physical_program)
lanes.visualize.debugger(move_program, arch)

from bloqade import decoders
table_decoder = decoders.TableDecoder(dem)
# Utilize a lookup table decoder to decode and obtain confidence.
correction, confidence = table_decoder.decode_confidence(syndrome)

# Define quantum operations on the shared Kernel IR.
from kirin import ir
quantum = ir.Dialect("quantum")
# ... Define statements and compiler passes

// Model virtual hardware; prototype a machine before touching silicon.
let mut qpu = Qpu::new(256, Topology::Grid);

let report = qpu.execute(QpuInstruction::Characterize)?;
println!("{report:#?}");