1use 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
15pub struct QpuExtension {
17 api_client: QpuApiClient,
18 capability: ExtensionCapability,
19}
20
21pub struct QpuApiClient {
23 providers: HashMap<String, QpuProvider>,
24 default_provider: String,
25}
26
27#[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#[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#[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#[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#[derive(Debug, Clone, Serialize, Deserialize)]
67pub struct QuantumMeasurement {
68 pub qubit: u32,
69 pub basis: String,
70}
71
72#[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
92pub struct DqcScheduler;
94
95impl DqcScheduler {
96 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 pub fn new() -> Self {
111 let mut providers = HashMap::new();
112
113 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 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 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 self.validate_circuit(¶ms.circuit, provider)?;
243
244 let start_time = Instant::now();
246 let result = self
247 .send_to_provider(provider, ¶ms.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 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 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, 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 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, 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 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, 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 let _program = qualia_q_forge::qasm::QasmProgram::new();
381 }
382
383 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 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, };
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); 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 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); }
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 counts.insert("0".repeat(circuit.qubits as usize), shots); 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 for (state, count) in &result.counts {
500 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 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; 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 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(¶ms.circuit)?;
644 let result = self.simulate_local(¶ms.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 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 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), (0.0, 0.0), (0.0, 0.0), (inv_sqrt2, 0.0), ];
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 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 let amplitude_quins: Vec<&NQuin> = quins
862 .iter()
863 .filter(|q| q.predicate == crate::q_hash("q42:hasStateAmplitude"))
864 .collect();
865
866 assert_eq!(amplitude_quins.len(), 2);
868
869 for amp_quin in &litude_quins {
870 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 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}