quantrs2-device 0.1.3

Quantum device connectors for the QuantRS2 framework
Documentation 
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

//! Continuous Variable Quantum Computing Demo
//!
//! This example demonstrates the basic functionality of the CV quantum system.

use quantrs2_device::continuous_variable::{
    create_gaussian_cv_device, CVGateSequence, Complex, GaussianState,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Continuous Variable Quantum Computing Demo ===");

    // Create a Gaussian CV device
    let mut device = create_gaussian_cv_device(2, None)?;
    println!("Created CV device with {} modes", device.num_modes);

    // Connect to the device
    device.connect().await?;
    println!("Connected to CV device");

    // Apply some basic operations
    println!("\nApplying displacement operation...");
    device.displacement(0, 1.0, 0.5).await?;

    println!("Applying squeezing operation...");
    device.squeezing(1, 1.0, 0.0).await?;

    println!("Applying beamsplitter...");
    device.beamsplitter(0, 1, 0.5, 0.0).await?;

    // Perform measurements
    println!("\nPerforming homodyne measurement...");
    let homodyne_result = device.homodyne_measurement(0, 0.0).await?;
    println!("Homodyne result: {homodyne_result:.3}");

    println!("Performing heterodyne measurement...");
    let heterodyne_result = device.heterodyne_measurement(1).await?;
    println!(
        "Heterodyne result: {:.3} + {:.3}i",
        heterodyne_result.real, heterodyne_result.imag
    );

    // Get device diagnostics
    let diagnostics = device.get_diagnostics().await;
    println!("\nDevice diagnostics:");
    println!("  Connected: {}", diagnostics.is_connected);
    println!("  Modes: {}", diagnostics.num_modes);
    println!("  Total measurements: {}", diagnostics.total_measurements);
    println!(
        "  Average squeezing: {:.3} dB",
        diagnostics.average_squeezing
    );
    println!("  System purity: {:.3}", diagnostics.system_purity);

    // Demonstrate CV gate sequences
    println!("\n=== CV Gate Sequence Demo ===");
    let mut gate_sequence = CVGateSequence::new(2);

    gate_sequence.displacement(0, Complex::new(2.0, 0.0))?;
    gate_sequence.squeezing(1, 0.5, 0.0)?;
    gate_sequence.beamsplitter(0, 1, 0.5, 0.0)?;

    println!(
        "Created gate sequence with {} gates",
        gate_sequence.gate_count()
    );
    println!("Sequence depth: {}", gate_sequence.depth());
    println!("Is Gaussian: {}", gate_sequence.is_gaussian());

    // Execute gate sequence on a state
    let mut state = GaussianState::vacuum_state(2);
    gate_sequence.execute_on_state(&mut state)?;
    println!("Executed gate sequence on vacuum state");

    // Show entanglement measures
    let entanglement = state.calculate_entanglement_measures();
    println!("Entanglement measures:");
    println!(
        "  Logarithmic negativity: {:.3}",
        entanglement.logarithmic_negativity
    );
    println!("  EPR correlation: {:.3}", entanglement.epr_correlation);

    println!("\n=== CV Demo Complete ===");
    Ok(())
}