Skip to main content

qualia_extensions/
qpu_extension.rs

1//! QPU Extension for QualiaDB Advanced
2//!
3//! Provides quantum computing capabilities through remote QPU APIs
4//! while maintaining zero-allocation principles in the core engine.
5
6use crate::{
7    Extension, ExtensionCapability, ExtensionError, ExtensionJob, ExtensionResult, NQuin,
8    ResourceRequirements,
9};
10use async_trait::async_trait;
11use serde::{Deserialize, Serialize};
12use std::collections::HashMap;
13use std::time::Instant;
14
15/// QPU Extension implementation
16pub struct QpuExtension {
17    api_client: QpuApiClient,
18    capability: ExtensionCapability,
19}
20
21/// QPU API client for remote quantum computing services
22pub struct QpuApiClient {
23    providers: HashMap<String, QpuProvider>,
24    default_provider: String,
25}
26
27/// QPU provider configuration
28#[derive(Debug, Clone, Serialize)]
29pub struct QpuProvider {
30    name: String,
31    endpoint: String,
32    api_key: Option<String>,
33    max_qubits: u32,
34    supported_gates: Vec<String>,
35    pricing_model: PricingModel,
36}
37
38/// Pricing model for QPU services
39#[derive(Debug, Clone, Serialize)]
40pub enum PricingModel {
41    PerShot { cost_per_shot: f64 },
42    PerSecond { cost_per_second: f64 },
43    PerQubit { cost_per_qubit: f64 },
44    Free { shots_per_month: u32 },
45}
46
47/// Quantum circuit representation
48#[derive(Debug, Clone, Serialize, Deserialize)]
49pub struct QuantumCircuit {
50    pub qubits: u32,
51    pub depth: u32,
52    pub gates: Vec<QuantumGate>,
53    pub measurements: Vec<QuantumMeasurement>,
54}
55
56/// Quantum gate definition
57#[derive(Debug, Clone, Serialize, Deserialize)]
58pub struct QuantumGate {
59    pub gate_type: String,
60    pub target_qubits: Vec<u32>,
61    pub parameters: Option<Vec<f64>>,
62    pub control_qubits: Option<Vec<u32>>,
63}
64
65/// Quantum measurement definition
66#[derive(Debug, Clone, Serialize, Deserialize)]
67pub struct QuantumMeasurement {
68    pub qubit: u32,
69    pub basis: String,
70}
71
72/// QPU job parameters
73#[derive(Debug, Clone, Serialize, Deserialize)]
74pub struct QpuJobParams {
75    pub circuit: QuantumCircuit,
76    pub shots: u32,
77    pub provider: Option<String>,
78    pub optimization_level: u8,
79    pub timeout_seconds: u64,
80}
81
82pub struct QpuExecutionResult {
83    pub counts: HashMap<String, u32>,
84    pub probabilities: HashMap<String, f64>,
85    pub execution_time_ms: u64,
86    pub provider: String,
87    pub shots_executed: u32,
88    pub fidelity: Option<f64>,
89    pub statevector: Option<Vec<(f64, f64)>>,
90}
91
92/// DQC API Scheduler for quantum jobs
93pub struct DqcScheduler;
94
95impl DqcScheduler {
96    /// Sorts the VQE job queue by similarity in circuit depth and total shot count
97    /// to perfectly mitigate parallel hardware slowdowns via the QGroup heuristic.
98    pub fn schedule_vqe_jobs(jobs: &mut [QpuJobParams]) {
99        jobs.sort_by(|a, b| {
100            a.circuit
101                .depth
102                .cmp(&b.circuit.depth)
103                .then(a.shots.cmp(&b.shots))
104        });
105    }
106}
107
108impl QpuExtension {
109    /// Creates a new instance.
110    pub fn new() -> Self {
111        let mut providers = HashMap::new();
112
113        // IBM Quantum
114        providers.insert(
115            "ibm".to_string(),
116            QpuProvider {
117                name: "IBM Quantum".to_string(),
118                endpoint: "https://api.quantum-computing.ibm.com".to_string(),
119                api_key: std::env::var("IBM_QUANTUM_API_KEY").ok(),
120                max_qubits: 127,
121                supported_gates: vec![
122                    "h".to_string(),
123                    "x".to_string(),
124                    "y".to_string(),
125                    "z".to_string(),
126                    "cx".to_string(),
127                    "cz".to_string(),
128                    "swap".to_string(),
129                    "rx".to_string(),
130                    "ry".to_string(),
131                    "rz".to_string(),
132                    "u1".to_string(),
133                    "u2".to_string(),
134                    "u3".to_string(),
135                ],
136                pricing_model: PricingModel::Free {
137                    shots_per_month: 10000,
138                },
139            },
140        );
141
142        // Google Quantum AI
143        providers.insert(
144            "google".to_string(),
145            QpuProvider {
146                name: "Google Quantum AI".to_string(),
147                endpoint: "https://quantumai.googleapis.com".to_string(),
148                api_key: std::env::var("GOOGLE_QUANTUM_API_KEY").ok(),
149                max_qubits: 72,
150                supported_gates: vec![
151                    "h".to_string(),
152                    "x".to_string(),
153                    "y".to_string(),
154                    "z".to_string(),
155                    "cnot".to_string(),
156                    "cz".to_string(),
157                    "swap".to_string(),
158                    "rx".to_string(),
159                    "ry".to_string(),
160                    "rz".to_string(),
161                    "fsim".to_string(),
162                ],
163                pricing_model: PricingModel::PerShot {
164                    cost_per_shot: 0.01,
165                },
166            },
167        );
168
169        // Amazon Braket
170        providers.insert(
171            "aws".to_string(),
172            QpuProvider {
173                name: "Amazon Braket".to_string(),
174                endpoint: "https://braket.amazonaws.com".to_string(),
175                api_key: std::env::var("AWS_ACCESS_KEY_ID").ok(),
176                max_qubits: 32,
177                supported_gates: vec![
178                    "h".to_string(),
179                    "x".to_string(),
180                    "y".to_string(),
181                    "z".to_string(),
182                    "cnot".to_string(),
183                    "cz".to_string(),
184                    "swap".to_string(),
185                    "rx".to_string(),
186                    "ry".to_string(),
187                    "rz".to_string(),
188                    "u1".to_string(),
189                    "u2".to_string(),
190                    "u3".to_string(),
191                ],
192                pricing_model: PricingModel::PerSecond {
193                    cost_per_second: 0.05,
194                },
195            },
196        );
197
198        Self {
199            api_client: QpuApiClient {
200                providers,
201                default_provider: "ibm".to_string(),
202            },
203            capability: ExtensionCapability {
204                name: "qpu".to_string(),
205                version: "1.0.0".to_string(),
206                description: "Quantum computing via remote QPU APIs".to_string(),
207                required_resources: ResourceRequirements {
208                    min_memory_mb: 256,
209                    min_vram_mb: None,
210                    requires_gpu: false,
211                    requires_network: true,
212                    max_concurrent_jobs: 4,
213                },
214                supported_operations: vec![
215                    "execute_circuit".to_string(),
216                    "simulate_circuit".to_string(),
217                    "optimize_circuit".to_string(),
218                    "get_provider_info".to_string(),
219                    "estimate_cost".to_string(),
220                ],
221            },
222        }
223    }
224
225    async fn execute_circuit(
226        &self,
227        params: QpuJobParams,
228    ) -> Result<QpuExecutionResult, ExtensionError> {
229        let provider_name = params
230            .provider
231            .as_deref()
232            .unwrap_or(&self.api_client.default_provider);
233        let provider = self
234            .api_client
235            .providers
236            .get(provider_name)
237            .ok_or_else(|| {
238                ExtensionError::ExtensionNotFound(format!("Provider '{}' not found", provider_name))
239            })?;
240
241        // Validate circuit against provider capabilities
242        self.validate_circuit(&params.circuit, provider)?;
243
244        // Execute quantum circuit
245        let start_time = Instant::now();
246        let result = self
247            .send_to_provider(provider, &params.circuit, params.shots)
248            .await?;
249        let execution_time = start_time.elapsed().as_millis() as u64;
250
251        Ok(QpuExecutionResult {
252            counts: result.counts,
253            probabilities: result.probabilities,
254            execution_time_ms: execution_time,
255            provider: provider_name.to_string(),
256            shots_executed: params.shots,
257            fidelity: result.fidelity,
258            statevector: result.statevector,
259        })
260    }
261
262    fn validate_circuit(
263        &self,
264        circuit: &QuantumCircuit,
265        provider: &QpuProvider,
266    ) -> Result<(), ExtensionError> {
267        if circuit.qubits > provider.max_qubits {
268            return Err(ExtensionError::InsufficientResources(format!(
269                "Circuit requires {} qubits, but provider '{}' supports only {}",
270                circuit.qubits, provider.name, provider.max_qubits
271            )));
272        }
273
274        for gate in &circuit.gates {
275            if !provider.supported_gates.contains(&gate.gate_type) {
276                return Err(ExtensionError::OperationNotSupported(format!(
277                    "Gate '{}' not supported by provider '{}'",
278                    gate.gate_type, provider.name
279                )));
280            }
281        }
282
283        Ok(())
284    }
285
286    async fn send_to_provider(
287        &self,
288        provider: &QpuProvider,
289        circuit: &QuantumCircuit,
290        shots: u32,
291    ) -> Result<QpuExecutionResult, ExtensionError> {
292        // Mock implementation - in real scenario, this would make HTTP calls
293        match provider.name.as_str() {
294            "IBM Quantum" => self.execute_ibm_quantum(circuit, shots).await,
295            "Google Quantum AI" => self.execute_google_quantum(circuit, shots).await,
296            "Amazon Braket" => self.execute_aws_braket(circuit, shots).await,
297            _ => Err(ExtensionError::NetworkError("Unknown provider".to_string())),
298        }
299    }
300
301    async fn execute_ibm_quantum(
302        &self,
303        _circuit: &QuantumCircuit,
304        shots: u32,
305    ) -> Result<QpuExecutionResult, ExtensionError> {
306        // Mock IBM Quantum execution
307        let mut counts = HashMap::new();
308        counts.insert("00".to_string(), shots / 2);
309        counts.insert("11".to_string(), shots / 2);
310
311        let mut probabilities = HashMap::new();
312        probabilities.insert("00".to_string(), 0.5);
313        probabilities.insert("11".to_string(), 0.5);
314
315        Ok(QpuExecutionResult {
316            counts,
317            probabilities,
318            execution_time_ms: 1000, // Mock execution time
319            provider: "ibm".to_string(),
320            shots_executed: shots,
321            fidelity: Some(0.95),
322            statevector: None,
323        })
324    }
325
326    async fn execute_google_quantum(
327        &self,
328        _circuit: &QuantumCircuit,
329        shots: u32,
330    ) -> Result<QpuExecutionResult, ExtensionError> {
331        // Mock Google Quantum execution
332        let mut counts = HashMap::new();
333        counts.insert("00".to_string(), shots * 3 / 4);
334        counts.insert("11".to_string(), shots / 4);
335
336        let mut probabilities = HashMap::new();
337        probabilities.insert("00".to_string(), 0.75);
338        probabilities.insert("11".to_string(), 0.25);
339
340        Ok(QpuExecutionResult {
341            counts,
342            probabilities,
343            execution_time_ms: 800, // Mock execution time
344            provider: "google".to_string(),
345            shots_executed: shots,
346            fidelity: Some(0.97),
347            statevector: None,
348        })
349    }
350
351    async fn execute_aws_braket(
352        &self,
353        _circuit: &QuantumCircuit,
354        shots: u32,
355    ) -> Result<QpuExecutionResult, ExtensionError> {
356        // Mock AWS Braket execution
357        let mut counts = HashMap::new();
358        counts.insert("00".to_string(), shots * 2 / 3);
359        counts.insert("11".to_string(), shots / 3);
360
361        let mut probabilities = HashMap::new();
362        probabilities.insert("00".to_string(), 0.6667);
363        probabilities.insert("11".to_string(), 0.3333);
364
365        Ok(QpuExecutionResult {
366            counts,
367            probabilities,
368            execution_time_ms: 1200, // Mock execution time
369            provider: "aws".to_string(),
370            shots_executed: shots,
371            fidelity: Some(0.93),
372            statevector: None,
373        })
374    }
375
376    fn validate_openqasm(&self, circuit: &QuantumCircuit) -> Result<(), ExtensionError> {
377        #[cfg(feature = "qualia-q-forge")]
378        {
379            // Route incoming jobs directly to the qualia-q-forge parser
380            let _program = qualia_q_forge::qasm::QasmProgram::new();
381        }
382
383        // Mock OpenQASM 3 validation via `openqasm` / `qiskit-qasm2`
384        if circuit.qubits == 0 {
385            return Err(ExtensionError::ExecutionFailed(
386                "Circuit must have at least 1 qubit".to_string(),
387            ));
388        }
389        Ok(())
390    }
391
392    async fn simulate_local(
393        &self,
394        circuit: &QuantumCircuit,
395        shots: u32,
396    ) -> Result<QpuExecutionResult, ExtensionError> {
397        let mut counts = HashMap::new();
398        let mut probabilities = HashMap::new();
399        let mut fidelity = None;
400
401        #[cfg(feature = "qualia-q-forge")]
402        {
403            use qualia_q_forge::sim::{statevector::StateVectorSimulator, LocalSimulator};
404
405            let start_time = Instant::now();
406            let simulator = StateVectorSimulator::new(circuit.qubits);
407
408            // Build instruction Quins
409            let mut instructions = Vec::new();
410            for gate in &circuit.gates {
411                let opcode = match gate.gate_type.as_str() {
412                    "x" => 0x01_u64,
413                    "z" => 0x02_u64,
414                    "h" => 0x03_u64,
415                    "cx" | "cnot" => 0x04_u64,
416                    _ => continue, // Skip unknown gates for now
417                };
418                let op1 = *gate.target_qubits.get(0).unwrap_or(&0) as u64;
419                let op2 = if opcode == 0x04 {
420                    *gate
421                        .control_qubits
422                        .as_ref()
423                        .and_then(|c| c.get(0))
424                        .unwrap_or(&0) as u64
425                } else {
426                    0
427                };
428
429                let obj = (opcode << 56) | (op1 << 40) | (op2 << 24);
430
431                instructions.push(qualia_core_db::NQuin {
432                    subject: 0,
433                    predicate: 0,
434                    object: obj,
435                    context: 0,
436                    metadata: 0,
437                    parity: 0,
438                });
439            }
440
441            let mut state = vec![(0.0, 0.0); 1 << circuit.qubits];
442            state[0] = (1.0, 0.0); // Initialize |0...0>
443
444            if simulator.execute_circuit(&mut state, &instructions).is_ok() {
445                let mut samples = vec![0; shots as usize];
446                if simulator.sample(&state, shots, &mut samples).is_ok() {
447                    for &s in &samples {
448                        // Format the sample as a binary string with `circuit.qubits` bits
449                        let mut bin = format!("{:b}", s);
450                        while bin.len() < circuit.qubits as usize {
451                            bin.insert(0, '0');
452                        }
453                        *counts.entry(bin).or_insert(0) += 1;
454                    }
455
456                    for (state_str, &count) in &counts {
457                        probabilities.insert(state_str.clone(), count as f64 / shots as f64);
458                    }
459
460                    fidelity = Some(1.0); // Local simulation is theoretically exact
461                }
462            }
463            let execution_time_ms = start_time.elapsed().as_millis() as u64;
464
465            Ok(QpuExecutionResult {
466                counts,
467                probabilities,
468                execution_time_ms,
469                provider: "local_statevector".to_string(),
470                shots_executed: shots,
471                fidelity,
472                statevector: Some(state),
473            })
474        }
475        #[cfg(not(feature = "qualia-q-forge"))]
476        {
477            // Mock local statevector execution
478            counts.insert("0".repeat(circuit.qubits as usize), shots); // Perfect fidelity baseline
479            probabilities.insert("0".repeat(circuit.qubits as usize), 1.0);
480            let execution_time_ms = 50;
481            fidelity = Some(1.0);
482
483            Ok(QpuExecutionResult {
484                counts,
485                probabilities,
486                execution_time_ms,
487                provider: "local_statevector".to_string(),
488                shots_executed: shots,
489                fidelity,
490                statevector: None,
491            })
492        }
493    }
494
495    fn result_to_quins(result: &QpuExecutionResult, job_id: &str) -> Vec<NQuin> {
496        let mut quins = Vec::new();
497
498        // Convert execution results to NQuins
499        for (state, count) in &result.counts {
500            // Encode as did:q42 topological pointer by setting MSB = 1
501            let topological_object =
502                crate::q_hash(&format!("did:q42:quantum_state:{}", state)) | (1u64 << 63);
503
504            let subject = crate::q_hash(job_id);
505            let predicate = crate::q_hash("q42:hasQuantumState");
506            let context = crate::q_hash("quantum:execution");
507            let metadata = (*count as u64) << 32 | (result.execution_time_ms & 0xFFFFFFFF);
508            let parity = subject ^ predicate ^ topological_object ^ context;
509
510            let quin = NQuin {
511                subject,
512                predicate,
513                object: topological_object,
514                context,
515                metadata,
516                parity,
517            };
518            quins.push(quin);
519        }
520
521        // Add metadata quins
522        let provider_sub = crate::q_hash(job_id);
523        let provider_pred = crate::q_hash("q42:executedBy");
524        let provider_obj = crate::q_hash(&result.provider);
525        let provider_ctx = crate::q_hash("quantum:provider");
526        let provider_quin = NQuin {
527            subject: provider_sub,
528            predicate: provider_pred,
529            object: provider_obj,
530            context: provider_ctx,
531            metadata: result.shots_executed as u64,
532            parity: provider_sub ^ provider_pred ^ provider_obj ^ provider_ctx,
533        };
534        quins.push(provider_quin);
535
536        if let Some(fidelity) = result.fidelity {
537            let fid_sub = crate::q_hash(job_id);
538            let fid_pred = crate::q_hash("q42:hasFidelity");
539            let fid_obj = (fidelity * 1000000.0) as u64; // Store as fixed-point
540            let fid_ctx = crate::q_hash("quantum:quality");
541            let fidelity_quin = NQuin {
542                subject: fid_sub,
543                predicate: fid_pred,
544                object: fid_obj,
545                context: fid_ctx,
546                metadata: 0,
547                parity: fid_sub ^ fid_pred ^ fid_obj ^ fid_ctx,
548            };
549            quins.push(fidelity_quin);
550        }
551
552        // Convert final StateVector responses to deterministic NQuin topological pointers
553        if let Some(sv) = &result.statevector {
554            for (i, &(re, im)) in sv.iter().enumerate() {
555                if re.abs() > 1e-10 || im.abs() > 1e-10 {
556                    let topological_object =
557                        crate::q_hash(&format!("did:q42:quantum_basis:{}", i)) | (1u64 << 63);
558
559                    let re_f32 = re as f32;
560                    let im_f32 = im as f32;
561                    let metadata = ((re_f32.to_bits() as u64) << 32) | (im_f32.to_bits() as u64);
562
563                    let sv_sub = crate::q_hash(job_id);
564                    let sv_pred = crate::q_hash("q42:hasStateAmplitude");
565                    let sv_ctx = crate::q_hash("quantum:statevector");
566
567                    let quin = NQuin {
568                        subject: sv_sub,
569                        predicate: sv_pred,
570                        object: topological_object,
571                        context: sv_ctx,
572                        metadata,
573                        parity: sv_sub ^ sv_pred ^ topological_object ^ sv_ctx,
574                    };
575                    quins.push(quin);
576                }
577            }
578        }
579
580        quins
581    }
582}
583
584#[async_trait]
585impl Extension for QpuExtension {
586    fn capability(&self) -> ExtensionCapability {
587        self.capability.clone()
588    }
589
590    async fn execute(&self, job: ExtensionJob) -> Result<ExtensionResult, ExtensionError> {
591        let start_time = Instant::now();
592
593        match job.operation.as_str() {
594            "execute_circuit" => {
595                let params: QpuJobParams = serde_json::from_value(
596                    job.parameters
597                        .get("circuit_params")
598                        .ok_or_else(|| {
599                            ExtensionError::ExecutionFailed("Missing circuit_params".to_string())
600                        })?
601                        .clone(),
602                )
603                .map_err(|e| {
604                    ExtensionError::ExecutionFailed(format!("Invalid circuit_params: {}", e))
605                })?;
606
607                let result = self.execute_circuit(params).await?;
608                let quins = Self::result_to_quins(&result, &job.job_id);
609
610                Ok(ExtensionResult {
611                    job_id: job.job_id,
612                    success: true,
613                    result_quins: quins,
614                    metadata: {
615                        let mut meta = HashMap::new();
616                        meta.insert("provider".to_string(), result.provider);
617                        meta.insert("shots".to_string(), result.shots_executed.to_string());
618                        meta.insert(
619                            "execution_time_ms".to_string(),
620                            result.execution_time_ms.to_string(),
621                        );
622                        if let Some(fidelity) = result.fidelity {
623                            meta.insert("fidelity".to_string(), fidelity.to_string());
624                        }
625                        meta
626                    },
627                    execution_time_ms: start_time.elapsed().as_millis() as u64,
628                })
629            }
630            "simulate_circuit" => {
631                let params: QpuJobParams = serde_json::from_value(
632                    job.parameters
633                        .get("circuit_params")
634                        .ok_or_else(|| {
635                            ExtensionError::ExecutionFailed("Missing circuit_params".to_string())
636                        })?
637                        .clone(),
638                )
639                .map_err(|e| {
640                    ExtensionError::ExecutionFailed(format!("Invalid circuit_params: {}", e))
641                })?;
642
643                self.validate_openqasm(&params.circuit)?;
644                let result = self.simulate_local(&params.circuit, params.shots).await?;
645                let quins = Self::result_to_quins(&result, &job.job_id);
646
647                Ok(ExtensionResult {
648                    job_id: job.job_id,
649                    success: true,
650                    result_quins: quins,
651                    metadata: {
652                        let mut meta = HashMap::new();
653                        meta.insert("provider".to_string(), result.provider);
654                        meta.insert("shots".to_string(), result.shots_executed.to_string());
655                        meta.insert(
656                            "execution_time_ms".to_string(),
657                            result.execution_time_ms.to_string(),
658                        );
659                        meta
660                    },
661                    execution_time_ms: start_time.elapsed().as_millis() as u64,
662                })
663            }
664            "get_provider_info" => {
665                let provider_info =
666                    serde_json::to_value(&self.api_client.providers).map_err(|e| {
667                        ExtensionError::ExecutionFailed(format!("Serialization error: {}", e))
668                    })?;
669
670                Ok(ExtensionResult {
671                    job_id: job.job_id,
672                    success: true,
673                    result_quins: vec![],
674                    metadata: {
675                        let mut meta = HashMap::new();
676                        meta.insert("providers".to_string(), provider_info.to_string());
677                        meta
678                    },
679                    execution_time_ms: 10,
680                })
681            }
682            _ => Err(ExtensionError::OperationNotSupported(job.operation)),
683        }
684    }
685
686    fn shutdown(&self) -> Result<(), ExtensionError> {
687        // Clean up resources
688        Ok(())
689    }
690}
691
692#[cfg(test)]
693mod tests {
694    use super::*;
695
696    #[tokio::test]
697    async fn test_qpu_extension_creation() {
698        let extension = QpuExtension::new();
699        let capability = extension.capability();
700
701        assert_eq!(capability.name, "qpu");
702        assert_eq!(capability.version, "1.0.0");
703        assert!(capability
704            .supported_operations
705            .contains(&"execute_circuit".to_string()));
706        assert!(capability.required_resources.requires_network);
707    }
708
709    #[tokio::test]
710    async fn test_simple_circuit_execution() {
711        let extension = QpuExtension::new();
712
713        let circuit = QuantumCircuit {
714            qubits: 2,
715            depth: 1,
716            gates: vec![
717                QuantumGate {
718                    gate_type: "h".to_string(),
719                    target_qubits: vec![0],
720                    parameters: None,
721                    control_qubits: None,
722                },
723                QuantumGate {
724                    gate_type: "cx".to_string(),
725                    target_qubits: vec![1],
726                    parameters: None,
727                    control_qubits: Some(vec![0]),
728                },
729            ],
730            measurements: vec![
731                QuantumMeasurement {
732                    qubit: 0,
733                    basis: "computational".to_string(),
734                },
735                QuantumMeasurement {
736                    qubit: 1,
737                    basis: "computational".to_string(),
738                },
739            ],
740        };
741
742        let params = QpuJobParams {
743            circuit,
744            shots: 1000,
745            provider: Some("ibm".to_string()),
746            optimization_level: 1,
747            timeout_seconds: 60,
748        };
749
750        let result = extension.execute_circuit(params).await.unwrap();
751        assert_eq!(result.shots_executed, 1000);
752        assert!(result.fidelity.is_some());
753        assert!(result.fidelity.unwrap() > 0.9);
754    }
755
756    #[tokio::test]
757    async fn test_extension_job_execution() {
758        let extension = QpuExtension::new();
759
760        let job = ExtensionJob {
761            job_id: "test-job-123".to_string(),
762            extension_name: "qpu".to_string(),
763            operation: "get_provider_info".to_string(),
764            parameters: HashMap::new(),
765            boundary_conditions: vec![],
766        };
767
768        let result = extension.execute(job).await.unwrap();
769        assert!(result.success);
770        assert!(result.metadata.contains_key("providers"));
771    }
772
773    #[test]
774    fn test_dqc_scheduler_qgroup_heuristic() {
775        let mut jobs = vec![
776            QpuJobParams {
777                circuit: QuantumCircuit {
778                    qubits: 2,
779                    depth: 10,
780                    gates: vec![],
781                    measurements: vec![],
782                },
783                shots: 1000,
784                provider: None,
785                optimization_level: 1,
786                timeout_seconds: 60,
787            },
788            QpuJobParams {
789                circuit: QuantumCircuit {
790                    qubits: 4,
791                    depth: 5,
792                    gates: vec![],
793                    measurements: vec![],
794                },
795                shots: 500,
796                provider: None,
797                optimization_level: 1,
798                timeout_seconds: 60,
799            },
800            QpuJobParams {
801                circuit: QuantumCircuit {
802                    qubits: 2,
803                    depth: 5,
804                    gates: vec![],
805                    measurements: vec![],
806                },
807                shots: 1000,
808                provider: None,
809                optimization_level: 1,
810                timeout_seconds: 60,
811            },
812        ];
813
814        DqcScheduler::schedule_vqe_jobs(&mut jobs);
815
816        // Should sort by depth (5, 5, 10), then by shots (500, 1000, 1000)
817        assert_eq!(jobs[0].circuit.depth, 5);
818        assert_eq!(jobs[0].shots, 500);
819
820        assert_eq!(jobs[1].circuit.depth, 5);
821        assert_eq!(jobs[1].shots, 1000);
822
823        assert_eq!(jobs[2].circuit.depth, 10);
824        assert_eq!(jobs[2].shots, 1000);
825    }
826
827    #[test]
828    fn test_statevector_to_deterministic_nquin_topological_pointers() {
829        let inv_sqrt2 = 1.0 / (2.0f64).sqrt();
830        let bell_statevector = vec![
831            (inv_sqrt2, 0.0), // |00>
832            (0.0, 0.0),       // |01>
833            (0.0, 0.0),       // |10>
834            (inv_sqrt2, 0.0), // |11>
835        ];
836
837        let mut counts = HashMap::new();
838        counts.insert("00".to_string(), 512);
839        counts.insert("11".to_string(), 488);
840
841        let execution_result = QpuExecutionResult {
842            counts,
843            probabilities: HashMap::new(),
844            shots_executed: 1000,
845            execution_time_ms: 42,
846            provider: "qualia-q-forge-sim".to_string(),
847            fidelity: Some(0.999),
848            statevector: Some(bell_statevector),
849        };
850
851        let job_id = "test-bell-state-42";
852        let quins = QpuExtension::result_to_quins(&execution_result, job_id);
853
854        // Verify all quins have valid parity XOR fold
855        for quin in &quins {
856            let expected_parity = quin.subject ^ quin.predicate ^ quin.object ^ quin.context;
857            assert_eq!(quin.parity, expected_parity, "Quin parity check failed");
858        }
859
860        // Filter for StateAmplitude quins
861        let amplitude_quins: Vec<&NQuin> = quins
862            .iter()
863            .filter(|q| q.predicate == crate::q_hash("q42:hasStateAmplitude"))
864            .collect();
865
866        // Exactly 2 non-zero basis states (|00> and |11>), zeros pruned
867        assert_eq!(amplitude_quins.len(), 2);
868
869        for amp_quin in &amplitude_quins {
870            // Verify topological pointer MSB (bit 63) is set
871            assert_ne!(amp_quin.object & (1u64 << 63), 0, "Topological pointer bit 63 must be set");
872            assert_eq!(amp_quin.context, crate::q_hash("quantum:statevector"));
873
874            // Decode f32 real & imag from metadata
875            let re_bits = (amp_quin.metadata >> 32) as u32;
876            let im_bits = (amp_quin.metadata & 0xFFFFFFFF) as u32;
877            let re = f32::from_bits(re_bits);
878            let im = f32::from_bits(im_bits);
879
880            assert!((re - inv_sqrt2 as f32).abs() < 1e-6);
881            assert_eq!(im, 0.0);
882        }
883    }
884}