Crate intrico 

Intrico - A High-Performance Quantum Computing Library

Intrico is a powerful and intuitive quantum computing library written in Rust, designed for high-performance quantum circuit simulation with a focus on memory efficiency and speed.

Features

• High Performance: Optimized gate execution kernels
• Memory Efficient: Support for up to 30 qubits with intelligent caching
• Type Safety: Comprehensive error handling with descriptive messages
• Easy to Use: Intuitive API for building and executing quantum circuits
• Standard Gates: Complete set of common quantum gates and operations

Quick Start

use intrico::{QuantumCircuit, QuantumState};
use intrico::error::Result;

fn main() -> Result<()> {
    // Create a 2-qubit quantum circuit
    let mut circuit = QuantumCircuit::new(2);
     
    // Add gates to create a Bell pair
    circuit.h(0)?  // Hadamard gate on qubit 0
           .cnot(0, 1)?;  // CNOT gate from qubit 0 to 1
     
    // Create initial quantum state |00⟩
    let mut state = QuantumState::new(2);
    println!("Initial: {}", state);
     
    // Execute the circuit
    circuit.execute(&mut state)?;
    println!("Final: {}", state);  // Should show Bell state (|00⟩ + |11⟩)/√2
     
    Ok(())
}

Core Components

Quantum States

• QuantumState - Multi-qubit quantum state vectors with amplitude manipulation
• Qubit - Optimized single-qubit states with factory methods

Quantum Gates

• QuantumGate - Unitary quantum gates with validation and standard gate constructors
• Standard gates: Pauli gates (X, Y, Z), Hadamard, CNOT, rotation gates, phase gates

Quantum Circuits

• QuantumCircuit - High-level circuit builder with gate tracking and execution
• Fluent API for chaining gate operations
• Optimized execution engine for single and multi-qubit gates

Performance Notes

• Maximum 30 qubits supported (2^30 = ~1 billion amplitudes)
• Optimized bit-stride algorithms for gate execution
• Cached normalization to avoid repeated calculations
• Memory-aligned operations for SIMD optimization potential

Examples

Creating Superposition

use intrico::{QuantumCircuit, QuantumState};

let mut circuit = QuantumCircuit::new(1);
circuit.h(0)?;  // Apply Hadamard to create (|0⟩ + |1⟩)/√2

let mut state = QuantumState::new(1);
circuit.execute(&mut state)?;

Custom Gates

use intrico::{QuantumGate, Amplitude};
use rusticle::Matrix;

// Create a custom rotation gate
let theta = std::f64::consts::PI / 4.0;
let cos_half = (theta / 2.0).cos();
let sin_half = (theta / 2.0).sin();

let matrix = Matrix::new(vec![
    Amplitude::new(cos_half, 0.0), Amplitude::new(0.0, -sin_half),
    Amplitude::new(0.0, -sin_half), Amplitude::new(cos_half, 0.0),
], 2, 2);

let custom_gate = QuantumGate::new(matrix, Some("Custom RX".to_string()))?;

Re-exports

pub use core::Amplitude;

pub use core::QuantumCircuit;

pub use core::QuantumGate;

pub use core::QuantumState;

pub use core::Qubit;

Modules

core

Core Quantum Computing Components

error

Error Handling for Intrico