Hugging Face's logo

Snapkitty
/
carry-agent

snapkitty
agents
python
Model card Files
xet
 Community
carry-agent
File size: 4,991 Bytes
80d7559
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
// CARRY Quantum Simulator Benchmark Suite
// Standard Reference Circuits & Multi-Agent Verification Overhead Benchmark Suite.

use std::time::Instant;
use crate::quantum::core::{Circuit, Gate, QuantumSimulator, SimulationMode, ErrorModel};

/// Benchmark Summary Result.
#[derive(Debug, Clone)]
pub struct BenchmarkReport {
    pub circuit_name: String,
    pub num_qubits: usize,
    pub num_gates: usize,
    pub shots: usize,
    pub execution_time_ms: u128,
    pub verification_overhead_ms: u128,
    pub fidelity: f64,
    pub status: String,
}

pub struct BenchmarkSuite;

impl BenchmarkSuite {
    /// Build Bell state circuit: H(0), CNOT(0, 1)
    pub fn build_bell_circuit() -> Circuit {
        let mut circuit = Circuit::new(2);
        circuit.add_gate(Gate::h(0));
        circuit.add_gate(Gate::cnot(0, 1));
        circuit
    }

    /// Build GHZ state circuit: H(0), CNOT(0, 1), CNOT(1, 2)
    pub fn build_ghz_circuit(num_qubits: usize) -> Circuit {
        let mut circuit = Circuit::new(num_qubits);
        circuit.add_gate(Gate::h(0));
        for i in 0..(num_qubits - 1) {
            circuit.add_gate(Gate::cnot(i, i + 1));
        }
        circuit
    }

    /// Build Quantum Teleportation circuit (3 qubits)
    pub fn build_teleportation_circuit() -> Circuit {
        let mut circuit = Circuit::new(3);
        // Prepare state on q0: H(0)
        circuit.add_gate(Gate::h(0));
        // Entangle Bell pair on q1, q2
        circuit.add_gate(Gate::h(1));
        circuit.add_gate(Gate::cnot(1, 2));
        // Bell measurement on q0, q1
        circuit.add_gate(Gate::cnot(0, 1));
        circuit.add_gate(Gate::h(0));
        // Corrections on q2
        circuit.add_gate(Gate::cnot(1, 2));
        circuit.add_gate(Gate::cz(0, 2));
        circuit
    }

    /// Build Deutsch-Jozsa circuit (2 qubits)
    pub fn build_deutsch_circuit() -> Circuit {
        let mut circuit = Circuit::new(2);
        circuit.add_gate(Gate::x(1));
        circuit.add_gate(Gate::h(0));
        circuit.add_gate(Gate::h(1));
        // Balanced oracle: CNOT(0, 1)
        circuit.add_gate(Gate::cnot(0, 1));
        circuit.add_gate(Gate::h(0));
        circuit
    }

    /// Build Grover 2-qubit search circuit
    pub fn build_grover_circuit() -> Circuit {
        let mut circuit = Circuit::new(2);
        // Equal superposition
        circuit.add_gate(Gate::h(0));
        circuit.add_gate(Gate::h(1));
        // Oracle for |11⟩: CZ(0, 1)
        circuit.add_gate(Gate::cz(0, 1));
        // Diffuser: H, X, CZ, X, H
        circuit.add_gate(Gate::h(0));
        circuit.add_gate(Gate::h(1));
        circuit.add_gate(Gate::x(0));
        circuit.add_gate(Gate::x(1));
        circuit.add_gate(Gate::cz(0, 1));
        circuit.add_gate(Gate::x(0));
        circuit.add_gate(Gate::x(1));
        circuit.add_gate(Gate::h(0));
        circuit.add_gate(Gate::h(1));
        circuit
    }

    /// Build QFT (Quantum Fourier Transform) circuit for n qubits
    pub fn build_qft_circuit(n: usize) -> Circuit {
        let mut circuit = Circuit::new(n);
        for i in 0..n {
            circuit.add_gate(Gate::h(i));
            for j in (i + 1)..n {
                let angle = std::f64::consts::PI / (1 << (j - i)) as f64;
                circuit.add_gate(Gate::rz(j, angle));
                circuit.add_gate(Gate::cz(i, j));
            }
        }
        for i in 0..(n / 2) {
            circuit.add_gate(Gate::swap(i, n - 1 - i));
        }
        circuit
    }

    /// Run full benchmark for a given circuit with execution timing & verification overhead measurement.
    pub fn run_benchmark(name: &str, circuit: &Circuit, shots: usize) -> Result<BenchmarkReport, String> {
        let start_time = Instant::now();
        let mut sim = QuantumSimulator::new(circuit.num_qubits, SimulationMode::StateVector, ErrorModel::None);

        // Execute circuit gates
        for gate in &circuit.gates {
            sim.apply_gate(gate)?;
        }
        let exec_time = start_time.elapsed().as_millis();

        // Verification overhead timing
        let verify_start = Instant::now();
        let _purity = sim.state.purity();
        let _valid = sim.state.is_valid_state();
        let verify_time = verify_start.elapsed().as_millis();

        Ok(BenchmarkReport {
            circuit_name: name.to_string(),
            num_qubits: circuit.num_qubits,
            num_gates: circuit.gates.len(),
            shots,
            execution_time_ms: exec_time,
            verification_overhead_ms: verify_time,
            // WC-3 fix: compute actual fidelity as post-circuit norm validity.
            // 1.0 = state remains normalised; values < 1.0 indicate drift.
            fidelity: if _valid { 1.0 - (_purity - 1.0).abs().min(1.0) } else { 0.0 },
            status: "SUCCESS".to_string(),
        })
    }
}