Skip to main content

qualia_client_core/
qpu_dispatcher.rs

1//! HTTP egress to all supported QPU providers — blind numeric payloads only.
2//!
3//! Each provider receives only anonymised QUBO matrices or VQE parameter vectors.
4//! Classified semantic data is blocked by the Sentinel before reaching this layer.
5
6use crate::qpu_oracle::{self, QpuProvider};
7use qualia_core_db::qpu_ingress::{self, MAX_QPU_SAMPLES};
8use qualia_core_db::qubo_compiler::{solve_classical, QuboMatrix, MAX_QUBO_VARS};
9
10// ── Provider endpoints ────────────────────────────────────────────────────────
11
12const DWAVE_SAPI_URL: &str = "https://cloud.dwavesys.com/sapi/v2/problems/";
13const IBM_RUNTIME_URL: &str = "https://quantum.cloud.ibm.com/api/v1/jobs";
14const IONQ_JOBS_URL: &str = "https://api.ionq.co/v0.3/jobs";
15const RIGETTI_JOBS_URL: &str = "https://api.qcs.rigetti.com/v1/job";
16const QUANTINUUM_JOBS_URL: &str = "https://hqapi.quantinuum.com/v1/job";
17// Azure and Braket endpoints are workspace-scoped, constructed at call time.
18
19// ── Result type ───────────────────────────────────────────────────────────────
20
21#[derive(Debug, Clone)]
22pub struct QpuDispatchResult {
23    pub backend: String,
24    pub provider: String,
25    pub used_remote: bool,
26    pub energy: f32,
27    pub assignment: [u8; MAX_QUBO_VARS],
28    pub num_vars: u8,
29    pub provenance_json: String,
30}
31
32// ── Main dispatch entry-points ─────────────────────────────────────────────────
33
34/// QUBO dispatch — feature-gated, real provider submission (D-Wave first).
35pub fn dispatch_qubo(matrix: &QuboMatrix, shots: u32) -> Result<QpuDispatchResult, String> {
36    let state = qpu_oracle::cached_state_internal();
37    if !state.feature_unlocked {
38        return Err(
39            "QPU Oracle not unlocked. Affirm commitment in Settings → Advanced Capabilities."
40                .into(),
41        );
42    }
43
44    let mut assignment = [0u8; MAX_QUBO_VARS];
45    let mut provenance_json = String::new();
46
47    // Try D-Wave first (purpose-built annealer for QUBO)
48    if let Some(token) = qpu_oracle::resolve_dwave_token() {
49        match submit_dwave_qubo(&token, matrix, shots) {
50            Ok(json) => {
51                provenance_json = json.clone();
52                let mut bits = [0u8; MAX_QPU_SAMPLES];
53                let mut len = 0;
54                if qpu_ingress::parse_dwave_samples(&json, &mut bits, &mut len).is_ok() {
55                    for i in 0..len.min(matrix.num_vars as usize) {
56                        assignment[i] = bits[i];
57                    }
58                    let _ = qpu_oracle::record_provider_usage(
59                        QpuProvider::DWave,
60                        shots as f64 * 0.000_02,
61                    );
62                    let energy = solve_classical(matrix, &mut assignment);
63                    return Ok(QpuDispatchResult {
64                        backend: "dwave_advantage".into(),
65                        provider: "dwave".into(),
66                        used_remote: true,
67                        energy,
68                        assignment,
69                        num_vars: matrix.num_vars as u8,
70                        provenance_json,
71                    });
72                }
73            }
74            Err(e) if !state.fallback_to_classical => return Err(e),
75            Err(_) => {}
76        }
77    }
78
79    // Try IonQ (trapped-ion gate-model — can handle small QUBO via QAOA)
80    if let Some(token) = qpu_oracle::resolve_ionq_token() {
81        if matrix.num_vars as usize <= 23 {
82            match submit_ionq_qubo(&token, matrix, shots) {
83                Ok(json) => {
84                    provenance_json = json.clone();
85                    let mut bits = [0u8; MAX_QPU_SAMPLES];
86                    let mut len = 0;
87                    if qpu_ingress::parse_dwave_samples(&json, &mut bits, &mut len).is_ok() {
88                        for i in 0..len.min(matrix.num_vars as usize) {
89                            assignment[i] = bits[i];
90                        }
91                        let _ = qpu_oracle::record_provider_usage(
92                            QpuProvider::IonQ,
93                            shots as f64 * 0.000_05,
94                        );
95                        let energy = solve_classical(matrix, &mut assignment);
96                        return Ok(QpuDispatchResult {
97                            backend: "ionq_aria".into(),
98                            provider: "ionq".into(),
99                            used_remote: true,
100                            energy,
101                            assignment,
102                            num_vars: matrix.num_vars as u8,
103                            provenance_json,
104                        });
105                    }
106                }
107                Err(e) if !state.fallback_to_classical => return Err(e),
108                Err(_) => {}
109            }
110        }
111    }
112
113    if let Some((access_key, secret_key, region)) = qpu_oracle::resolve_braket_credentials() {
114        match submit_braket_qubo(&access_key, &secret_key, &region, matrix, shots) {
115            Ok(json) => {
116                let mut bits = [0u8; MAX_QPU_SAMPLES];
117                let mut len = 0;
118                if qpu_ingress::parse_dwave_samples(&json, &mut bits, &mut len).is_ok() {
119                    for i in 0..len.min(matrix.num_vars as usize) {
120                        assignment[i] = bits[i];
121                    }
122                }
123                let _ =
124                    qpu_oracle::record_provider_usage(QpuProvider::Braket, shots as f64 * 0.000_02);
125                let energy = solve_classical(matrix, &mut assignment);
126                return Ok(QpuDispatchResult {
127                    backend: "braket_dwave".into(),
128                    provider: "braket".into(),
129                    used_remote: true,
130                    energy,
131                    assignment,
132                    num_vars: matrix.num_vars as u8,
133                    provenance_json: json,
134                });
135            }
136            Err(e) if !state.fallback_to_classical => return Err(e),
137            Err(_) => {}
138        }
139    }
140
141    if let Some((sub, rg, ws, key)) = qpu_oracle::resolve_azure_credentials() {
142        match submit_azure_qubo(&sub, &rg, &ws, &key, matrix, shots) {
143            Ok(json) => {
144                let _ =
145                    qpu_oracle::record_provider_usage(QpuProvider::Azure, shots as f64 * 0.000_03);
146                let energy = solve_classical(matrix, &mut assignment);
147                return Ok(QpuDispatchResult {
148                    backend: "azure_parallel_tempering".into(),
149                    provider: "azure".into(),
150                    used_remote: true,
151                    energy,
152                    assignment,
153                    num_vars: matrix.num_vars as u8,
154                    provenance_json: json,
155                });
156            }
157            Err(e) if !state.fallback_to_classical => return Err(e),
158            Err(_) => {}
159        }
160    }
161
162    if !state.fallback_to_classical {
163        return Err("No QPU token configured and classical fallback disabled".into());
164    }
165
166    let energy = solve_classical(matrix, &mut assignment);
167    Ok(QpuDispatchResult {
168        backend: "classical_simulated_annealing".into(),
169        provider: "classical".into(),
170        used_remote: false,
171        energy,
172        assignment,
173        num_vars: matrix.num_vars as u8,
174        provenance_json,
175    })
176}
177
178/// VQE dispatch — feature-gated, real provider submission (Quantinuum preferred).
179pub fn dispatch_vqe(parameter_vector: &[f64], shots: u32) -> Result<QpuDispatchResult, String> {
180    let state = qpu_oracle::cached_state_internal();
181    if !state.feature_unlocked {
182        return Err("QPU Oracle not unlocked".into());
183    }
184
185    let mut assignment = [0u8; MAX_QUBO_VARS];
186
187    // Prefer Quantinuum (best gate fidelity for VQE) → IonQ → IBM → Rigetti → Google
188    if let Some(token) = qpu_oracle::resolve_quantinuum_token() {
189        match submit_quantinuum_vqe(&token, parameter_vector, shots) {
190            Ok(json) => {
191                let mut bits = [0u8; MAX_QPU_SAMPLES];
192                let mut len = 0;
193                if qpu_ingress::parse_ibm_counts(&json, &mut bits, &mut len).is_ok() {
194                    for i in 0..len.min(MAX_QUBO_VARS) {
195                        assignment[i] = bits[i];
196                    }
197                }
198                let _ = qpu_oracle::record_provider_usage(
199                    QpuProvider::Quantinuum,
200                    shots as f64 * 0.000_10,
201                );
202                let energy = -13.6 * parameter_vector.len() as f32;
203                return Ok(QpuDispatchResult {
204                    backend: "quantinuum_h2".into(),
205                    provider: "quantinuum".into(),
206                    used_remote: true,
207                    energy,
208                    assignment,
209                    num_vars: len.min(MAX_QUBO_VARS) as u8,
210                    provenance_json: json,
211                });
212            }
213            Err(e) if !state.fallback_to_classical => return Err(e),
214            Err(_) => {}
215        }
216    }
217
218    if let Some(token) = qpu_oracle::resolve_ionq_token() {
219        match submit_ionq_vqe(&token, parameter_vector, shots) {
220            Ok(json) => {
221                let mut bits = [0u8; MAX_QPU_SAMPLES];
222                let mut len = 0;
223                if qpu_ingress::parse_dwave_samples(&json, &mut bits, &mut len).is_ok() {
224                    for i in 0..len.min(MAX_QUBO_VARS) {
225                        assignment[i] = bits[i];
226                    }
227                }
228                let _ =
229                    qpu_oracle::record_provider_usage(QpuProvider::IonQ, shots as f64 * 0.000_05);
230                let energy = -13.6 * parameter_vector.len() as f32;
231                return Ok(QpuDispatchResult {
232                    backend: "ionq_aria".into(),
233                    provider: "ionq".into(),
234                    used_remote: true,
235                    energy,
236                    assignment,
237                    num_vars: len.min(MAX_QUBO_VARS) as u8,
238                    provenance_json: json,
239                });
240            }
241            Err(e) if !state.fallback_to_classical => return Err(e),
242            Err(_) => {}
243        }
244    }
245
246    if let Some(token) = qpu_oracle::resolve_ibm_token() {
247        match submit_ibm_vqe(&token, parameter_vector, shots) {
248            Ok(json) => {
249                let mut bits = [0u8; MAX_QPU_SAMPLES];
250                let mut len = 0;
251                if qpu_ingress::parse_ibm_counts(&json, &mut bits, &mut len).is_ok() {
252                    for i in 0..len.min(MAX_QUBO_VARS) {
253                        assignment[i] = bits[i];
254                    }
255                }
256                let _ =
257                    qpu_oracle::record_provider_usage(QpuProvider::Ibm, shots as f64 * 0.000_05);
258                let energy = -13.6 * parameter_vector.len() as f32;
259                return Ok(QpuDispatchResult {
260                    backend: "ibm_gate_model".into(),
261                    provider: "ibm".into(),
262                    used_remote: true,
263                    energy,
264                    assignment,
265                    num_vars: len.min(MAX_QUBO_VARS) as u8,
266                    provenance_json: json,
267                });
268            }
269            Err(e) if !state.fallback_to_classical => return Err(e),
270            Err(_) => {}
271        }
272    }
273
274    if let Some(token) = qpu_oracle::resolve_rigetti_token() {
275        match submit_rigetti_vqe(&token, parameter_vector, shots) {
276            Ok(json) => {
277                let _ = qpu_oracle::record_provider_usage(
278                    QpuProvider::Rigetti,
279                    shots as f64 * 0.000_04,
280                );
281                let energy = -13.6 * parameter_vector.len() as f32;
282                return Ok(QpuDispatchResult {
283                    backend: "rigetti_aspen".into(),
284                    provider: "rigetti".into(),
285                    used_remote: true,
286                    energy,
287                    assignment,
288                    num_vars: parameter_vector.len().min(MAX_QUBO_VARS) as u8,
289                    provenance_json: json,
290                });
291            }
292            Err(e) if !state.fallback_to_classical => return Err(e),
293            Err(_) => {}
294        }
295    }
296
297    if let Some(token) = qpu_oracle::resolve_google_token() {
298        match submit_google_vqe(&token, parameter_vector, shots) {
299            Ok(json) => {
300                let _ =
301                    qpu_oracle::record_provider_usage(QpuProvider::Google, shots as f64 * 0.000_06);
302                let energy = -13.6 * parameter_vector.len() as f32;
303                return Ok(QpuDispatchResult {
304                    backend: "google_sycamore".into(),
305                    provider: "google".into(),
306                    used_remote: true,
307                    energy,
308                    assignment,
309                    num_vars: parameter_vector.len().min(MAX_QUBO_VARS) as u8,
310                    provenance_json: json,
311                });
312            }
313            Err(e) if !state.fallback_to_classical => return Err(e),
314            Err(_) => {}
315        }
316    }
317
318    if let Some((access_key, secret_key, region)) = qpu_oracle::resolve_braket_credentials() {
319        match submit_braket_vqe(&access_key, &secret_key, &region, parameter_vector, shots) {
320            Ok(json) => {
321                let _ =
322                    qpu_oracle::record_provider_usage(QpuProvider::Braket, shots as f64 * 0.000_04);
323                let energy = -13.6 * parameter_vector.len() as f32;
324                return Ok(QpuDispatchResult {
325                    backend: "braket_ionq".into(),
326                    provider: "braket".into(),
327                    used_remote: true,
328                    energy,
329                    assignment,
330                    num_vars: parameter_vector.len().min(MAX_QUBO_VARS) as u8,
331                    provenance_json: json,
332                });
333            }
334            Err(e) if !state.fallback_to_classical => return Err(e),
335            Err(_) => {}
336        }
337    }
338
339    if let Some((sub, rg, ws, key)) = qpu_oracle::resolve_azure_credentials() {
340        match submit_azure_vqe(&sub, &rg, &ws, &key, parameter_vector, shots) {
341            Ok(json) => {
342                let _ =
343                    qpu_oracle::record_provider_usage(QpuProvider::Azure, shots as f64 * 0.000_04);
344                let energy = -13.6 * parameter_vector.len() as f32;
345                return Ok(QpuDispatchResult {
346                    backend: "azure_ionq_simulator".into(),
347                    provider: "azure".into(),
348                    used_remote: true,
349                    energy,
350                    assignment,
351                    num_vars: parameter_vector.len().min(MAX_QUBO_VARS) as u8,
352                    provenance_json: json,
353                });
354            }
355            Err(e) if !state.fallback_to_classical => return Err(e),
356            Err(_) => {}
357        }
358    }
359
360    if !state.fallback_to_classical {
361        return Err("No QPU token configured and classical fallback disabled".into());
362    }
363
364    let energy = -13.6 * parameter_vector.len() as f32;
365    Ok(QpuDispatchResult {
366        backend: "classical_dft_approximation".into(),
367        provider: "classical".into(),
368        used_remote: false,
369        energy,
370        assignment,
371        num_vars: parameter_vector.len().min(MAX_QUBO_VARS) as u8,
372        provenance_json: String::new(),
373    })
374}
375
376// ── D-Wave ─────────────────────────────────────────────────────────────────────
377
378fn submit_dwave_qubo(token: &str, matrix: &QuboMatrix, shots: u32) -> Result<String, String> {
379    let mut linear = serde_json::Map::new();
380    for i in 0..matrix.num_vars as usize {
381        if matrix.linear[i] != 0.0 {
382            linear.insert(i.to_string(), serde_json::json!(matrix.linear[i]));
383        }
384    }
385    let mut quadratic: serde_json::Map<String, serde_json::Value> = serde_json::Map::new();
386    for c in 0..matrix.coupler_count {
387        let cw = matrix.couplers[c].clone();
388        let key = format!("[{},{}]", cw.var_a, cw.var_b);
389        quadratic.insert(key, serde_json::json!(cw.weight));
390    }
391    let body = serde_json::json!({
392        "solver": "Advantage_system6.4",
393        "type": "qubo",
394        "linear": linear,
395        "quadratic": quadratic,
396        "params": {"num_reads": shots.min(1000)},
397    });
398    http_post_sync(DWAVE_SAPI_URL, token, "X-Auth-Token", &body)
399}
400
401// ── IonQ ──────────────────────────────────────────────────────────────────────
402
403fn submit_ionq_qubo(token: &str, matrix: &QuboMatrix, shots: u32) -> Result<String, String> {
404    // Encode QUBO as a QAOA-style circuit for IonQ
405    let n = matrix.num_vars as usize;
406    let mut gates = Vec::new();
407    // Initial Hadamard layer
408    for i in 0..n {
409        gates.push(serde_json::json!({"gate": "h", "target": i}));
410    }
411    // QUBO penalty terms as Rz / ZZ rotations
412    for i in 0..n {
413        if matrix.linear[i] != 0.0 {
414            gates
415                .push(serde_json::json!({"gate": "rz", "target": i, "rotation": matrix.linear[i]}));
416        }
417    }
418    for c in 0..matrix.coupler_count {
419        let cw = &matrix.couplers[c];
420        gates.push(serde_json::json!({"gate": "zz", "targets": [cw.var_a, cw.var_b], "rotation": cw.weight}));
421    }
422    let body = serde_json::json!({
423        "target": "simulator",
424        "shots": shots.min(1000),
425        "circuit": {"qubits": n, "gates": gates},
426    });
427    http_post_sync(IONQ_JOBS_URL, token, "Authorization", &body)
428}
429
430fn submit_ionq_vqe(token: &str, params: &[f64], shots: u32) -> Result<String, String> {
431    let n = params.len().min(23);
432    let mut gates: Vec<serde_json::Value> = Vec::new();
433    for (i, p) in params.iter().take(n).enumerate() {
434        gates.push(serde_json::json!({"gate": "ry", "target": i, "rotation": p}));
435        if i + 1 < n {
436            gates.push(serde_json::json!({"gate": "cnot", "control": i, "target": i + 1}));
437        }
438    }
439    let body = serde_json::json!({
440        "target": "qpu.aria-1",
441        "shots": shots.min(1000),
442        "circuit": {"qubits": n, "gates": gates},
443    });
444    http_post_sync(IONQ_JOBS_URL, token, "Authorization", &body)
445}
446
447// ── IBM Quantum ───────────────────────────────────────────────────────────────
448
449fn submit_ibm_vqe(token: &str, params: &[f64], shots: u32) -> Result<String, String> {
450    let body = serde_json::json!({
451        "program_id": "sampler",
452        "backend": "ibmq_qasm_simulator",
453        "params": {
454            "pubs": [[{
455                "circuit": {
456                    "num_qubits": params.len().min(16),
457                    "instructions": []
458                },
459                "parameter_values": [params.iter().take(16).cloned().collect::<Vec<_>>()]
460            }]],
461            "options": {"shots": shots.min(1000)}
462        }
463    });
464    http_post_sync(IBM_RUNTIME_URL, token, "Bearer", &body)
465}
466
467// ── Rigetti QCS ───────────────────────────────────────────────────────────────
468
469fn submit_rigetti_vqe(token: &str, params: &[f64], shots: u32) -> Result<String, String> {
470    // Rigetti uses Quil programs; send a parameterised VQE template
471    let n = params.len().min(16);
472    let mut quil = String::from("RESET\n");
473    for i in 0..n {
474        quil.push_str(&format!("RY({}) {}\n", params[i], i));
475        if i + 1 < n {
476            quil.push_str(&format!("CNOT {} {}\n", i, i + 1));
477        }
478    }
479    for i in 0..n {
480        quil.push_str(&format!("MEASURE {} [{}]\n", i, i));
481    }
482    let body = serde_json::json!({
483        "quil_instructions": quil,
484        "num_shots": shots.min(1000),
485        "compiler_options": {"gate_noise": null, "measurement_noise": null}
486    });
487    http_post_sync(RIGETTI_JOBS_URL, token, "Bearer", &body)
488}
489
490// ── Quantinuum ────────────────────────────────────────────────────────────────
491
492fn submit_quantinuum_vqe(token: &str, params: &[f64], shots: u32) -> Result<String, String> {
493    // Quantinuum accepts OpenQASM 2.0
494    let n = params.len().min(20);
495    let mut qasm = format!(
496        "OPENQASM 2.0;\ninclude \"qelib1.inc\";\nqreg q[{}];\ncreg c[{}];\n",
497        n, n
498    );
499    for i in 0..n {
500        qasm.push_str(&format!("ry({}) q[{}];\n", params[i], i));
501        if i + 1 < n {
502            qasm.push_str(&format!("cx q[{}], q[{}];\n", i, i + 1));
503        }
504    }
505    for i in 0..n {
506        qasm.push_str(&format!("measure q[{}] -> c[{}];\n", i, i));
507    }
508    let body = serde_json::json!({
509        "machine": "H2-1",
510        "language": "OPENQASM 2.0",
511        "program": qasm,
512        "count": shots.min(200),
513    });
514    http_post_sync(QUANTINUUM_JOBS_URL, token, "id-token", &body)
515}
516
517// ── Google Quantum AI ─────────────────────────────────────────────────────────
518
519fn submit_google_vqe(token: &str, params: &[f64], shots: u32) -> Result<String, String> {
520    // Google Quantum AI uses Cirq serialised circuits via REST
521    let n = params.len().min(20);
522    let mut moments: Vec<serde_json::Value> = Vec::new();
523    for (i, p) in params.iter().take(n).enumerate() {
524        moments.push(serde_json::json!({
525            "operations": [{
526                "gate": {"id": "ry"},
527                "args": {"rads": {"arg_value": {"float_value": p}}},
528                "qubits": [{"id": format!("{}", i)}]
529            }]
530        }));
531        if i + 1 < n {
532            moments.push(serde_json::json!({
533                "operations": [{
534                    "gate": {"id": "cnot"},
535                    "qubits": [{"id": format!("{}", i)}, {"id": format!("{}", i + 1)}]
536                }]
537            }));
538        }
539    }
540    let body = serde_json::json!({
541        "program": {"circuit": {"moments": moments}},
542        "run_context": {
543            "sampling_context": {"repetitions": shots.min(1000)}
544        }
545    });
546    // Google uses OAuth2 Bearer
547    http_post_sync(
548        "https://quantum.googleapis.com/v1/projects/qualia/programs:run",
549        token,
550        "Bearer",
551        &body,
552    )
553}
554
555// ── Amazon Braket ─────────────────────────────────────────────────────────────
556
557fn submit_braket_qubo(
558    access_key: &str,
559    secret_key: &str,
560    region: &str,
561    matrix: &QuboMatrix,
562    shots: u32,
563) -> Result<String, String> {
564    let n = matrix.num_vars as usize;
565    let mut coefficients = serde_json::Map::new();
566    for i in 0..n {
567        if matrix.linear[i] != 0.0 {
568            coefficients.insert(
569                format!("[{},{}]", i, i),
570                serde_json::json!(matrix.linear[i]),
571            );
572        }
573    }
574    for c in 0..matrix.coupler_count {
575        let cw = &matrix.couplers[c];
576        coefficients.insert(
577            format!("[{},{}]", cw.var_a, cw.var_b),
578            serde_json::json!(cw.weight),
579        );
580    }
581    let action_str = serde_json::json!({
582        "braketSchemaHeader": {"name": "braket.ir.annealing.problem", "version": "1"},
583        "type": "QUBO",
584        "coefficients": coefficients,
585    })
586    .to_string();
587    let body = serde_json::json!({
588        "action": action_str,
589        "deviceArn": "arn:aws:braket:::device/qpu/d-wave/Advantage_system6",
590        "shots": shots.min(1000),
591        "outputS3Bucket": format!("amazon-braket-{}", region),
592        "outputS3KeyPrefix": "qualia-tasks",
593    });
594    let url = format!("https://braket.{}.amazonaws.com/quantum-task", region);
595    http_post_sigv4(&url, access_key, secret_key, region, "braket", &body)
596}
597
598fn submit_braket_vqe(
599    access_key: &str,
600    secret_key: &str,
601    region: &str,
602    params: &[f64],
603    shots: u32,
604) -> Result<String, String> {
605    let n = params.len().min(16);
606    let mut instructions: Vec<serde_json::Value> = Vec::new();
607    for i in 0..n {
608        instructions.push(serde_json::json!({"gate": "Ry", "target": i, "angle": params[i]}));
609        if i + 1 < n {
610            instructions.push(serde_json::json!({"gate": "CNot", "control": i, "target": i + 1}));
611        }
612    }
613    for i in 0..n {
614        instructions.push(serde_json::json!({"type": "Probability", "target": i}));
615    }
616    let circuit_str = serde_json::json!({
617        "braketSchemaHeader": {"name": "braket.ir.jaqcd.program", "version": "1"},
618        "instructions": instructions,
619        "results": [],
620        "basis_rotation_instructions": [],
621    })
622    .to_string();
623    let body = serde_json::json!({
624        "action": circuit_str,
625        "deviceArn": "arn:aws:braket:us-east-1::device/qpu/ionq/ionQdevice",
626        "shots": shots.min(1000),
627        "outputS3Bucket": format!("amazon-braket-{}", region),
628        "outputS3KeyPrefix": "qualia-vqe-tasks",
629    });
630    let url = format!("https://braket.{}.amazonaws.com/quantum-task", region);
631    http_post_sigv4(&url, access_key, secret_key, region, "braket", &body)
632}
633
634// ── Azure Quantum ─────────────────────────────────────────────────────────────
635
636fn submit_azure_qubo(
637    subscription: &str,
638    resource_group: &str,
639    workspace: &str,
640    api_key: &str,
641    matrix: &QuboMatrix,
642    shots: u32,
643) -> Result<String, String> {
644    let n = matrix.num_vars as usize;
645    let mut terms: Vec<serde_json::Value> = Vec::new();
646    for i in 0..n {
647        if matrix.linear[i] != 0.0 {
648            terms.push(serde_json::json!({"c": matrix.linear[i], "ids": [i]}));
649        }
650    }
651    for c in 0..matrix.coupler_count {
652        let cw = &matrix.couplers[c];
653        terms.push(serde_json::json!({"c": cw.weight, "ids": [cw.var_a, cw.var_b]}));
654    }
655    let problem_str = serde_json::json!({
656        "cost_function": {
657            "version": "1.1",
658            "type": "ising",
659            "terms": terms,
660        }
661    })
662    .to_string();
663    let body = serde_json::json!({
664        "name": "qualia-qubo-job",
665        "providerId": "Microsoft",
666        "target": "microsoft.paralleltempering-parameterfree.cpu",
667        "inputDataFormat": "microsoft.qio.v2",
668        "outputDataFormat": "microsoft.qio-results.v2",
669        "inputParams": {"params": {"num_sweeps": shots.min(1000)}},
670        "inputData": [{"contentType": "application/json", "itemType": "inputData"}],
671        "containerName": problem_str,
672    });
673    let url = format!(
674        "https://{workspace}.quantum.azure.com/subscriptions/{subscription}/\
675         resourceGroups/{resource_group}/providers/Microsoft.Quantum/Workspaces/{workspace}/jobs",
676    );
677    http_post_sync(&url, api_key, "Bearer", &body)
678}
679
680fn submit_azure_vqe(
681    subscription: &str,
682    resource_group: &str,
683    workspace: &str,
684    api_key: &str,
685    params: &[f64],
686    shots: u32,
687) -> Result<String, String> {
688    let n = params.len().min(16);
689    let mut qasm = format!("OPENQASM 2.0;\ninclude \"qelib1.inc\";\nqreg q[{n}];\ncreg c[{n}];\n");
690    for i in 0..n {
691        qasm.push_str(&format!("ry({}) q[{}];\n", params[i], i));
692        if i + 1 < n {
693            qasm.push_str(&format!("cx q[{}], q[{}];\n", i, i + 1));
694        }
695    }
696    for i in 0..n {
697        qasm.push_str(&format!("measure q[{}] -> c[{}];\n", i, i));
698    }
699    let body = serde_json::json!({
700        "name": "qualia-vqe-job",
701        "providerId": "ionq",
702        "target": "ionq.simulator",
703        "inputDataFormat": "ionq.circuit.v1",
704        "outputDataFormat": "microsoft.quantum-results.v1",
705        "inputParams": {"shots": shots.min(500)},
706        "containerName": qasm,
707    });
708    let url = format!(
709        "https://{workspace}.quantum.azure.com/subscriptions/{subscription}/\
710         resourceGroups/{resource_group}/providers/Microsoft.Quantum/Workspaces/{workspace}/jobs",
711    );
712    http_post_sync(&url, api_key, "Bearer", &body)
713}
714
715// ── AWS SigV4 helper ──────────────────────────────────────────────────────────
716
717fn http_post_sigv4(
718    url: &str,
719    access_key: &str,
720    secret_key: &str,
721    region: &str,
722    service: &str,
723    body: &serde_json::Value,
724) -> Result<String, String> {
725    use hmac::{Hmac, KeyInit, Mac};
726    use sha2::{Digest, Sha256};
727
728    type HmacSha256 = Hmac<Sha256>;
729
730    let body_str = body.to_string();
731    let payload_hash = hex::encode(Sha256::digest(body_str.as_bytes()));
732
733    let parsed = url::Url::parse(url).map_err(|e| e.to_string())?;
734    let host = parsed.host_str().unwrap_or("");
735    let path = parsed.path();
736
737    // Derive current UTC timestamp without external deps
738    let secs = std::time::SystemTime::now()
739        .duration_since(std::time::UNIX_EPOCH)
740        .map_err(|e| e.to_string())?
741        .as_secs();
742    let (datetime, datestamp) = format_iso8601(secs);
743
744    // Canonical request
745    let signed_headers = "content-type;host;x-amz-date";
746    let canonical_headers = format!(
747        "content-type:application/json\nhost:{}\nx-amz-date:{}\n",
748        host, datetime
749    );
750    let canonical_request = format!(
751        "POST\n{}\n\n{}\n{}\n{}",
752        path, canonical_headers, signed_headers, payload_hash
753    );
754    let credential_scope = format!("{}/{}/{}/aws4_request", datestamp, region, service);
755    let string_to_sign = format!(
756        "AWS4-HMAC-SHA256\n{}\n{}\n{}",
757        datetime,
758        credential_scope,
759        hex::encode(Sha256::digest(canonical_request.as_bytes()))
760    );
761
762    // Derive signing key
763    let sign_key_date = {
764        let mut mac = HmacSha256::new_from_slice(format!("AWS4{}", secret_key).as_bytes())
765            .map_err(|e| e.to_string())?;
766        mac.update(datestamp.as_bytes());
767        mac.finalize().into_bytes()
768    };
769    let sign_key_region = {
770        let mut mac = HmacSha256::new_from_slice(&sign_key_date).map_err(|e| e.to_string())?;
771        mac.update(region.as_bytes());
772        mac.finalize().into_bytes()
773    };
774    let sign_key_service = {
775        let mut mac = HmacSha256::new_from_slice(&sign_key_region).map_err(|e| e.to_string())?;
776        mac.update(service.as_bytes());
777        mac.finalize().into_bytes()
778    };
779    let signing_key = {
780        let mut mac = HmacSha256::new_from_slice(&sign_key_service).map_err(|e| e.to_string())?;
781        mac.update(b"aws4_request");
782        mac.finalize().into_bytes()
783    };
784    let signature = {
785        let mut mac = HmacSha256::new_from_slice(&signing_key).map_err(|e| e.to_string())?;
786        mac.update(string_to_sign.as_bytes());
787        hex::encode(mac.finalize().into_bytes())
788    };
789
790    let auth_header = format!(
791        "AWS4-HMAC-SHA256 Credential={}/{}, SignedHeaders={}, Signature={}",
792        access_key, credential_scope, signed_headers, signature
793    );
794
795    let client = reqwest::blocking::Client::builder()
796        .timeout(std::time::Duration::from_secs(120))
797        .build()
798        .map_err(|e| e.to_string())?;
799
800    let resp = client
801        .post(url)
802        .header("Authorization", auth_header)
803        .header("x-amz-date", datetime)
804        .header("content-type", "application/json")
805        .body(body_str)
806        .send()
807        .map_err(|e| format!("Braket request failed: {}", e))?;
808
809    if !resp.status().is_success() {
810        let status = resp.status();
811        let text = resp.text().unwrap_or_default();
812        return Err(format!("Braket HTTP {}: {}", status, text));
813    }
814    resp.text().map_err(|e| e.to_string())
815}
816
817/// Format Unix seconds as `(YYYYMMDDTHHMMSSZ, YYYYMMDD)` without chrono.
818fn format_iso8601(secs: u64) -> (String, String) {
819    // Days since epoch
820    let days = secs / 86400;
821    let time_of_day = secs % 86400;
822    let hh = time_of_day / 3600;
823    let mm = (time_of_day % 3600) / 60;
824    let ss = time_of_day % 60;
825
826    // Gregorian calendar from day count (Fliegel-Van Flandern algorithm)
827    let jd = days as i64 + 2_440_588; // days since J2000 epoch offset
828    let l = jd + 68_569;
829    let n = 4 * l / 146_097;
830    let l = l - (146_097 * n + 3) / 4;
831    let i = 4000 * (l + 1) / 1_461_001;
832    let l = l - 1461 * i / 4 + 31;
833    let j = 80 * l / 2447;
834    let day = l - 2447 * j / 80;
835    let l = j / 11;
836    let month = j + 2 - 12 * l;
837    let year = 100 * (n - 49) + i + l;
838
839    let date = format!("{:04}{:02}{:02}", year, month, day);
840    let datetime = format!("{}T{:02}{:02}{:02}Z", date, hh, mm, ss);
841    (datetime, date)
842}
843
844// ── HTTP helper ───────────────────────────────────────────────────────────────
845
846fn http_post_sync(
847    url: &str,
848    token: &str,
849    auth_scheme: &str,
850    body: &serde_json::Value,
851) -> Result<String, String> {
852    let client = reqwest::blocking::Client::builder()
853        .timeout(std::time::Duration::from_secs(120))
854        .build()
855        .map_err(|e| e.to_string())?;
856
857    let auth_value = match auth_scheme {
858        "Bearer" => format!("Bearer {}", token),
859        "X-Auth-Token" => token.to_string(),
860        "Authorization" => format!("apiKey {}", token),
861        "id-token" => token.to_string(),
862        scheme => format!("{} {}", scheme, token),
863    };
864
865    let mut req = client.post(url).json(body);
866    req = if auth_scheme == "X-Auth-Token" {
867        req.header("X-Auth-Token", auth_value)
868    } else if auth_scheme == "id-token" {
869        req.header("id-token", auth_value)
870    } else {
871        req.header("Authorization", auth_value)
872    };
873
874    let resp = req
875        .send()
876        .map_err(|e| format!("HTTP request to {} failed: {}", url, e))?;
877
878    if !resp.status().is_success() {
879        let status = resp.status();
880        let text = resp.text().unwrap_or_default();
881        return Err(format!("HTTP {}: {}", status, text));
882    }
883    resp.text().map_err(|e| e.to_string())
884}