quantrs2_device/

ibm.rs

use quantrs2_circuit::prelude::Circuit;
#[cfg(feature = "ibm")]
use std::collections::HashMap;
#[cfg(feature = "ibm")]
use std::sync::Arc;
#[cfg(feature = "ibm")]
use std::thread::sleep;
#[cfg(feature = "ibm")]
use std::time::Duration;

#[cfg(feature = "ibm")]
use reqwest::{header, Client};
#[cfg(feature = "ibm")]
use serde::{Deserialize, Serialize};
use thiserror::Error;

use crate::DeviceError;
use crate::DeviceResult;

#[cfg(feature = "ibm")]
const IBM_QUANTUM_API_URL: &str = "https://api.quantum-computing.ibm.com/api";
#[cfg(feature = "ibm")]
const DEFAULT_TIMEOUT_SECS: u64 = 90;

/// Represents the available backends on IBM Quantum
#[derive(Debug, Clone)]
#[cfg_attr(feature = "ibm", derive(serde::Deserialize))]
pub struct IBMBackend {
    /// Unique identifier for the backend
    pub id: String,
    /// Name of the backend
    pub name: String,
    /// Whether the backend is a simulator or real quantum hardware
    pub simulator: bool,
    /// Number of qubits on the backend
    pub n_qubits: usize,
    /// Status of the backend (e.g., "active", "maintenance")
    pub status: String,
    /// Description of the backend
    pub description: String,
    /// Version of the backend
    pub version: String,
}

/// Configuration for a quantum circuit to be submitted to IBM Quantum
#[derive(Debug, Clone)]
#[cfg_attr(feature = "ibm", derive(Serialize))]
pub struct IBMCircuitConfig {
    /// Name of the circuit
    pub name: String,
    /// QASM representation of the circuit
    pub qasm: String,
    /// Number of shots to run
    pub shots: usize,
    /// Optional optimization level (0-3)
    pub optimization_level: Option<usize>,
    /// Optional initial layout mapping
    pub initial_layout: Option<std::collections::HashMap<String, usize>>,
}

/// Status of a job in IBM Quantum
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "ibm", derive(Deserialize))]
pub enum IBMJobStatus {
    #[cfg_attr(feature = "ibm", serde(rename = "CREATING"))]
    Creating,
    #[cfg_attr(feature = "ibm", serde(rename = "CREATED"))]
    Created,
    #[cfg_attr(feature = "ibm", serde(rename = "VALIDATING"))]
    Validating,
    #[cfg_attr(feature = "ibm", serde(rename = "VALIDATED"))]
    Validated,
    #[cfg_attr(feature = "ibm", serde(rename = "QUEUED"))]
    Queued,
    #[cfg_attr(feature = "ibm", serde(rename = "RUNNING"))]
    Running,
    #[cfg_attr(feature = "ibm", serde(rename = "COMPLETED"))]
    Completed,
    #[cfg_attr(feature = "ibm", serde(rename = "CANCELLED"))]
    Cancelled,
    #[cfg_attr(feature = "ibm", serde(rename = "ERROR"))]
    Error,
}

/// Response from submitting a job to IBM Quantum
#[cfg(feature = "ibm")]
#[derive(Debug, Deserialize)]
pub struct IBMJobResponse {
    /// Job ID
    pub id: String,
    /// Status of the job
    pub status: IBMJobStatus,
    /// Number of shots
    pub shots: usize,
    /// Backend used for the job
    pub backend: IBMBackend,
}

#[cfg(not(feature = "ibm"))]
#[derive(Debug)]
pub struct IBMJobResponse {
    /// Job ID
    pub id: String,
    /// Status of the job
    pub status: IBMJobStatus,
    /// Number of shots
    pub shots: usize,
}

/// Results from a completed job
#[cfg(feature = "ibm")]
#[derive(Debug, Deserialize)]
pub struct IBMJobResult {
    /// Counts of each basis state
    pub counts: HashMap<String, usize>,
    /// Total number of shots executed
    pub shots: usize,
    /// Status of the job
    pub status: IBMJobStatus,
    /// Error message, if any
    pub error: Option<String>,
}

#[cfg(not(feature = "ibm"))]
#[derive(Debug)]
pub struct IBMJobResult {
    /// Counts of each basis state
    pub counts: std::collections::HashMap<String, usize>,
    /// Total number of shots executed
    pub shots: usize,
    /// Status of the job
    pub status: IBMJobStatus,
    /// Error message, if any
    pub error: Option<String>,
}

/// Errors specific to IBM Quantum
#[derive(Error, Debug)]
pub enum IBMQuantumError {
    #[error("Authentication error: {0}")]
    Authentication(String),

    #[error("API error: {0}")]
    API(String),

    #[error("Backend not available: {0}")]
    BackendUnavailable(String),

    #[error("QASM conversion error: {0}")]
    QasmConversion(String),

    #[error("Job submission error: {0}")]
    JobSubmission(String),

    #[error("Timeout waiting for job completion")]
    Timeout,
}

/// Client for interacting with IBM Quantum
#[cfg(feature = "ibm")]
#[derive(Clone)]
pub struct IBMQuantumClient {
    /// HTTP client for making API requests
    client: Client,
    /// Base URL for the IBM Quantum API
    api_url: String,
    /// Authentication token
    token: String,
}

#[cfg(not(feature = "ibm"))]
#[derive(Clone)]
pub struct IBMQuantumClient;

#[cfg(feature = "ibm")]
impl IBMQuantumClient {
    /// Create a new IBM Quantum client with the given token
    pub fn new(token: &str) -> DeviceResult<Self> {
        let mut headers = header::HeaderMap::new();
        headers.insert(
            header::CONTENT_TYPE,
            header::HeaderValue::from_static("application/json"),
        );

        let client = Client::builder()
            .default_headers(headers)
            .timeout(Duration::from_secs(30))
            .build()
            .map_err(|e| DeviceError::Connection(e.to_string()))?;

        Ok(Self {
            client,
            api_url: IBM_QUANTUM_API_URL.to_string(),
            token: token.to_string(),
        })
    }

    /// List all available backends
    pub async fn list_backends(&self) -> DeviceResult<Vec<IBMBackend>> {
        let response = self
            .client
            .get(&format!("{}/backends", self.api_url))
            .header("Authorization", format!("Bearer {}", self.token))
            .send()
            .await
            .map_err(|e| DeviceError::Connection(e.to_string()))?;

        if !response.status().is_success() {
            let error_msg = response
                .text()
                .await
                .unwrap_or_else(|_| "Unknown error".to_string());
            return Err(DeviceError::APIError(error_msg));
        }

        let backends: Vec<IBMBackend> = response
            .json()
            .await
            .map_err(|e| DeviceError::Deserialization(e.to_string()))?;

        Ok(backends)
    }

    /// Get details about a specific backend
    pub async fn get_backend(&self, backend_name: &str) -> DeviceResult<IBMBackend> {
        let response = self
            .client
            .get(&format!("{}/backends/{}", self.api_url, backend_name))
            .header("Authorization", format!("Bearer {}", self.token))
            .send()
            .await
            .map_err(|e| DeviceError::Connection(e.to_string()))?;

        if !response.status().is_success() {
            let error_msg = response
                .text()
                .await
                .unwrap_or_else(|_| "Unknown error".to_string());
            return Err(DeviceError::APIError(error_msg));
        }

        let backend: IBMBackend = response
            .json()
            .await
            .map_err(|e| DeviceError::Deserialization(e.to_string()))?;

        Ok(backend)
    }

    /// Submit a circuit to be executed on an IBM Quantum backend
    pub async fn submit_circuit(
        &self,
        backend_name: &str,
        config: IBMCircuitConfig,
    ) -> DeviceResult<String> {
        #[cfg(feature = "ibm")]
        {
            use serde_json::json;

            let payload = json!({
                "backend": backend_name,
                "name": config.name,
                "qasm": config.qasm,
                "shots": config.shots,
                "optimization_level": config.optimization_level.unwrap_or(1),
                "initial_layout": config.initial_layout.unwrap_or_default(),
            });

            let response = self
                .client
                .post(&format!("{}/jobs", self.api_url))
                .header("Authorization", format!("Bearer {}", self.token))
                .json(&payload)
                .send()
                .await
                .map_err(|e| DeviceError::Connection(e.to_string()))?;

            if !response.status().is_success() {
                let error_msg = response
                    .text()
                    .await
                    .unwrap_or_else(|_| "Unknown error".to_string());
                return Err(DeviceError::JobSubmission(error_msg));
            }

            let job_response: IBMJobResponse = response
                .json()
                .await
                .map_err(|e| DeviceError::Deserialization(e.to_string()))?;

            Ok(job_response.id)
        }

        #[cfg(not(feature = "ibm"))]
        Err(DeviceError::UnsupportedDevice(
            "IBM Quantum support not enabled".to_string(),
        ))
    }

    /// Get the status of a job
    pub async fn get_job_status(&self, job_id: &str) -> DeviceResult<IBMJobStatus> {
        let response = self
            .client
            .get(&format!("{}/jobs/{}", self.api_url, job_id))
            .header("Authorization", format!("Bearer {}", self.token))
            .send()
            .await
            .map_err(|e| DeviceError::Connection(e.to_string()))?;

        if !response.status().is_success() {
            let error_msg = response
                .text()
                .await
                .unwrap_or_else(|_| "Unknown error".to_string());
            return Err(DeviceError::APIError(error_msg));
        }

        let job: IBMJobResponse = response
            .json()
            .await
            .map_err(|e| DeviceError::Deserialization(e.to_string()))?;

        Ok(job.status)
    }

    /// Get the results of a completed job
    pub async fn get_job_result(&self, job_id: &str) -> DeviceResult<IBMJobResult> {
        let response = self
            .client
            .get(&format!("{}/jobs/{}/result", self.api_url, job_id))
            .header("Authorization", format!("Bearer {}", self.token))
            .send()
            .await
            .map_err(|e| DeviceError::Connection(e.to_string()))?;

        if !response.status().is_success() {
            let error_msg = response
                .text()
                .await
                .unwrap_or_else(|_| "Unknown error".to_string());
            return Err(DeviceError::APIError(error_msg));
        }

        let result: IBMJobResult = response
            .json()
            .await
            .map_err(|e| DeviceError::Deserialization(e.to_string()))?;

        Ok(result)
    }

    /// Wait for a job to complete with timeout
    pub async fn wait_for_job(
        &self,
        job_id: &str,
        timeout_secs: Option<u64>,
    ) -> DeviceResult<IBMJobResult> {
        let timeout = timeout_secs.unwrap_or(DEFAULT_TIMEOUT_SECS);
        let mut elapsed = 0;
        let interval = 5; // Check status every 5 seconds

        while elapsed < timeout {
            let status = self.get_job_status(job_id).await?;

            match status {
                IBMJobStatus::Completed => {
                    return self.get_job_result(job_id).await;
                }
                IBMJobStatus::Error => {
                    return Err(DeviceError::JobExecution(format!(
                        "Job {} encountered an error",
                        job_id
                    )));
                }
                IBMJobStatus::Cancelled => {
                    return Err(DeviceError::JobExecution(format!(
                        "Job {} was cancelled",
                        job_id
                    )));
                }
                _ => {
                    // Still in progress, wait and check again
                    sleep(Duration::from_secs(interval));
                    elapsed += interval;
                }
            }
        }

        Err(DeviceError::Timeout(format!(
            "Timed out waiting for job {} to complete",
            job_id
        )))
    }

    /// Submit multiple circuits in parallel
    pub async fn submit_circuits_parallel(
        &self,
        backend_name: &str,
        configs: Vec<IBMCircuitConfig>,
    ) -> DeviceResult<Vec<String>> {
        #[cfg(feature = "ibm")]
        {
            use tokio::task;

            let client = Arc::new(self.clone());

            let mut handles = vec![];

            for config in configs {
                let client_clone = client.clone();
                let backend_name = backend_name.to_string();

                let handle =
                    task::spawn(
                        async move { client_clone.submit_circuit(&backend_name, config).await },
                    );

                handles.push(handle);
            }

            let mut job_ids = vec![];

            for handle in handles {
                match handle.await {
                    Ok(result) => match result {
                        Ok(job_id) => job_ids.push(job_id),
                        Err(e) => return Err(e),
                    },
                    Err(e) => {
                        return Err(DeviceError::JobSubmission(format!(
                            "Failed to join task: {}",
                            e
                        )));
                    }
                }
            }

            Ok(job_ids)
        }

        #[cfg(not(feature = "ibm"))]
        Err(DeviceError::UnsupportedDevice(
            "IBM Quantum support not enabled".to_string(),
        ))
    }

    /// Convert a Quantrs circuit to QASM
    pub fn circuit_to_qasm<const N: usize>(
        _circuit: &Circuit<N>,
        _initial_layout: Option<std::collections::HashMap<String, usize>>,
    ) -> DeviceResult<String> {
        // This is a placeholder for the actual conversion logic
        // In a complete implementation, this would translate our circuit representation
        // to OpenQASM format compatible with IBM Quantum

        let mut qasm = String::from("OPENQASM 2.0;\ninclude \"qelib1.inc\";\n\n");

        // Define the quantum and classical registers
        qasm.push_str(&format!("qreg q[{}];\n", N));
        qasm.push_str(&format!("creg c[{}];\n\n", N));

        // Implement conversion of gates to QASM here
        // For example:
        // - X gate: x q[i];
        // - H gate: h q[i];
        // - CNOT gate: cx q[i], q[j];

        // For now, just return placeholder QASM
        Ok(qasm)
    }
}

#[cfg(not(feature = "ibm"))]
impl IBMQuantumClient {
    pub fn new(_token: &str) -> DeviceResult<Self> {
        Err(DeviceError::UnsupportedDevice(
            "IBM Quantum support not enabled. Recompile with the 'ibm' feature.".to_string(),
        ))
    }

    pub async fn list_backends(&self) -> DeviceResult<Vec<IBMBackend>> {
        Err(DeviceError::UnsupportedDevice(
            "IBM Quantum support not enabled".to_string(),
        ))
    }

    pub async fn get_backend(&self, _backend_name: &str) -> DeviceResult<IBMBackend> {
        Err(DeviceError::UnsupportedDevice(
            "IBM Quantum support not enabled".to_string(),
        ))
    }

    pub async fn submit_circuit(
        &self,
        _backend_name: &str,
        _config: IBMCircuitConfig,
    ) -> DeviceResult<String> {
        Err(DeviceError::UnsupportedDevice(
            "IBM Quantum support not enabled".to_string(),
        ))
    }

    pub async fn get_job_status(&self, _job_id: &str) -> DeviceResult<IBMJobStatus> {
        Err(DeviceError::UnsupportedDevice(
            "IBM Quantum support not enabled".to_string(),
        ))
    }

    pub async fn get_job_result(&self, _job_id: &str) -> DeviceResult<IBMJobResult> {
        Err(DeviceError::UnsupportedDevice(
            "IBM Quantum support not enabled".to_string(),
        ))
    }

    pub async fn wait_for_job(
        &self,
        _job_id: &str,
        _timeout_secs: Option<u64>,
    ) -> DeviceResult<IBMJobResult> {
        Err(DeviceError::UnsupportedDevice(
            "IBM Quantum support not enabled".to_string(),
        ))
    }

    pub async fn submit_circuits_parallel(
        &self,
        _backend_name: &str,
        _configs: Vec<IBMCircuitConfig>,
    ) -> DeviceResult<Vec<String>> {
        Err(DeviceError::UnsupportedDevice(
            "IBM Quantum support not enabled".to_string(),
        ))
    }

    pub fn circuit_to_qasm<const N: usize>(
        _circuit: &Circuit<N>,
        _initial_layout: Option<std::collections::HashMap<String, usize>>,
    ) -> DeviceResult<String> {
        Err(DeviceError::UnsupportedDevice(
            "IBM Quantum support not enabled".to_string(),
        ))
    }
}