|
|
|
|
|
|
| use std::collections::HashMap;
|
|
|
|
|
| #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
| pub enum QuantumDAGNodeType {
|
| Input,
|
| StatePreparation,
|
| Entanglement,
|
| AgentComputation,
|
| PartnerVerification,
|
| QuantumOperation,
|
| Measurement,
|
| ICPGate,
|
| Commit,
|
| }
|
|
|
|
|
| #[derive(Debug, Clone)]
|
| pub struct QuantumDAGNode {
|
| pub id: usize,
|
| pub node_type: QuantumDAGNodeType,
|
| pub label: String,
|
| pub agent_id: String,
|
| pub target_qubits: Vec<usize>,
|
| pub provenance_hash: String,
|
| pub parent_ids: Vec<usize>,
|
| }
|
|
|
|
|
| #[derive(Debug, Clone)]
|
| pub struct QuantumDAG {
|
| pub nodes: HashMap<usize, QuantumDAGNode>,
|
| pub next_node_id: usize,
|
| pub execution_order: Vec<usize>,
|
| }
|
|
|
| impl QuantumDAG {
|
| pub fn new() -> Self {
|
| Self {
|
| nodes: HashMap::new(),
|
| next_node_id: 1,
|
| execution_order: Vec::new(),
|
| }
|
| }
|
|
|
|
|
| pub fn add_node(
|
| &mut self,
|
| node_type: QuantumDAGNodeType,
|
| label: impl Into<String>,
|
| agent_id: impl Into<String>,
|
| target_qubits: Vec<usize>,
|
| parent_ids: Vec<usize>,
|
| ) -> Result<usize, String> {
|
| let label_str = label.into();
|
| let agent_str = agent_id.into();
|
|
|
|
|
| for &parent_id in &parent_ids {
|
| if !self.nodes.contains_key(&parent_id) {
|
| return Err(format!("DAG_ERROR: Parent node {} does not exist", parent_id));
|
| }
|
| }
|
|
|
|
|
| if node_type == QuantumDAGNodeType::Commit {
|
| let has_icp_parent = parent_ids.iter().any(|&p| {
|
| self.nodes.get(&p).map(|n| n.node_type) == Some(QuantumDAGNodeType::ICPGate)
|
| });
|
| if !has_icp_parent {
|
| return Err("INVALID_DAG_PATH: Commit node must be preceded by an ICP Gate node".into());
|
| }
|
| }
|
|
|
| let id = self.next_node_id;
|
| self.next_node_id += 1;
|
|
|
|
|
| let provenance_hash = format!(
|
| "NODE_{:?}_AG_{}_Q{:?}_P{:?}",
|
| node_type, agent_str, target_qubits, parent_ids
|
| );
|
|
|
| let node = QuantumDAGNode {
|
| id,
|
| node_type,
|
| label: label_str,
|
| agent_id: agent_str,
|
| target_qubits,
|
| provenance_hash,
|
| parent_ids,
|
| };
|
|
|
| self.nodes.insert(id, node);
|
| self.execution_order.push(id);
|
| Ok(id)
|
| }
|
|
|
|
|
| pub fn validate_path(&self) -> Result<(), String> {
|
| if self.execution_order.is_empty() {
|
| return Err("DAG is empty".into());
|
| }
|
|
|
| let first = self.nodes.get(&self.execution_order[0]).unwrap();
|
| if first.node_type != QuantumDAGNodeType::Input {
|
| return Err("DAG path must start with Input node".into());
|
| }
|
|
|
| let last = self.nodes.get(self.execution_order.last().unwrap()).unwrap();
|
| if last.node_type != QuantumDAGNodeType::Commit {
|
| return Err("DAG path must terminate with Commit node".into());
|
| }
|
|
|
| Ok(())
|
| }
|
| }
|
|
|
