The HAL Contract

import arvak
from qiskit import QuantumCircuit

# Create a circuit in Qiskit
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Use Arvak as a Qiskit backend
from arvak.integrations.qiskit import ArvakProvider

provider = ArvakProvider()
backend = provider.get_backend('sim')
job = backend.run(qc, shots=1000)
result = job.result()
print(result.get_counts())

# Convert between frameworks seamlessly
qiskit_int = arvak.get_integration('qiskit')
arvak_circuit = qiskit_int.to_arvak(qc)

# Works with Cirq, Qrisp, PennyLane too
print(arvak.list_integrations())
# {'qiskit': True, 'qrisp': True, 'cirq': True, 'pennylane': True}

/// The core Backend trait — HAL Contract v2
#[async_trait]
pub trait Backend: Send + Sync {
    /// Get the name of this backend
    fn name(&self) -> &str;

    /// Capabilities — sync, infallible, cached at construction
    fn capabilities(&self) -> &Capabilities;

    /// Availability — queue depth, wait time, status
    async fn availability(&self) -> HalResult<BackendAvailability>;

    /// Validate circuit against backend constraints
    async fn validate(&self, circuit: &Circuit) -> HalResult<ValidationResult>;

    /// Submit a circuit for execution
    async fn submit(&self, circuit: &Circuit, shots: u32) -> HalResult<JobId>;

    /// Get the status of a job
    async fn status(&self, job_id: &JobId) -> HalResult<JobStatus>;

    /// Get the result of a completed job
    async fn result(&self, job_id: &JobId) -> HalResult<ExecutionResult>;

    /// Cancel a running job
    async fn cancel(&self, job_id: &JobId) -> HalResult<()>;

    /// Wait for a job to complete (provided default implementation)
    async fn wait(&self, job_id: &JobId) -> HalResult<ExecutionResult>;
}