Struct Tensor 

pub struct Tensor {
    pub data: Vec<Complex<f64>>,
    pub shape: Vec<usize>,
    pub indices: Vec<String>,
}

Tensor representing a quantum gate or state

Fields

data: Vec<Complex<f64>>

Tensor data in row-major order

shape: Vec<usize>

Shape of the tensor (dimensions)

indices: Vec<String>

Labels for each index

Implementations

impl Tensor

pub fn new( data: Vec<Complex<f64>>, shape: Vec<usize>, indices: Vec<String>, ) -> Self

Create a new tensor

Examples found in repository

examples/tensor_network_demo.rs (lines 43-47)

fn demo_basic_tensor_network() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Basic Tensor Network Construction ---");

    // Create simple tensors
    let identity = Tensor::identity(2, "in".to_string(), "out".to_string());
    println!(
        "Created identity tensor: rank={}, size={}",
        identity.rank(),
        identity.size()
    );

    // Create Hadamard tensor
    let h_data = vec![
        C64::new(1.0 / 2.0_f64.sqrt(), 0.0),
        C64::new(1.0 / 2.0_f64.sqrt(), 0.0),
        C64::new(1.0 / 2.0_f64.sqrt(), 0.0),
        C64::new(-1.0 / 2.0_f64.sqrt(), 0.0),
    ];
    let h_tensor = Tensor::new(
        h_data,
        vec![2, 2],
        vec!["h_in".to_string(), "h_out".to_string()],
    );

    // Build tensor network
    let mut tn = TensorNetwork::new();
    let id_idx = tn.add_tensor(identity);
    let h_idx = tn.add_tensor(h_tensor);

    // Connect tensors
    tn.add_bond(id_idx, "out".to_string(), h_idx, "h_in".to_string())?;

    println!("Built tensor network with {} tensors and {} bonds", 2, 1);
    println!();

    Ok(())
}

pub fn identity(dim: usize, in_label: String, out_label: String) -> Self

Create an identity tensor

Examples found in repository

examples/tensor_network_demo.rs (line 29)

fn demo_basic_tensor_network() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Basic Tensor Network Construction ---");

    // Create simple tensors
    let identity = Tensor::identity(2, "in".to_string(), "out".to_string());
    println!(
        "Created identity tensor: rank={}, size={}",
        identity.rank(),
        identity.size()
    );

    // Create Hadamard tensor
    let h_data = vec![
        C64::new(1.0 / 2.0_f64.sqrt(), 0.0),
        C64::new(1.0 / 2.0_f64.sqrt(), 0.0),
        C64::new(1.0 / 2.0_f64.sqrt(), 0.0),
        C64::new(-1.0 / 2.0_f64.sqrt(), 0.0),
    ];
    let h_tensor = Tensor::new(
        h_data,
        vec![2, 2],
        vec!["h_in".to_string(), "h_out".to_string()],
    );

    // Build tensor network
    let mut tn = TensorNetwork::new();
    let id_idx = tn.add_tensor(identity);
    let h_idx = tn.add_tensor(h_tensor);

    // Connect tensors
    tn.add_bond(id_idx, "out".to_string(), h_idx, "h_in".to_string())?;

    println!("Built tensor network with {} tensors and {} bonds", 2, 1);
    println!();

    Ok(())
}

pub fn rank(&self) -> usize

Get the rank (number of indices)

Examples found in repository

examples/tensor_network_demo.rs (line 32)

fn demo_basic_tensor_network() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Basic Tensor Network Construction ---");

    // Create simple tensors
    let identity = Tensor::identity(2, "in".to_string(), "out".to_string());
    println!(
        "Created identity tensor: rank={}, size={}",
        identity.rank(),
        identity.size()
    );

    // Create Hadamard tensor
    let h_data = vec![
        C64::new(1.0 / 2.0_f64.sqrt(), 0.0),
        C64::new(1.0 / 2.0_f64.sqrt(), 0.0),
        C64::new(1.0 / 2.0_f64.sqrt(), 0.0),
        C64::new(-1.0 / 2.0_f64.sqrt(), 0.0),
    ];
    let h_tensor = Tensor::new(
        h_data,
        vec![2, 2],
        vec!["h_in".to_string(), "h_out".to_string()],
    );

    // Build tensor network
    let mut tn = TensorNetwork::new();
    let id_idx = tn.add_tensor(identity);
    let h_idx = tn.add_tensor(h_tensor);

    // Connect tensors
    tn.add_bond(id_idx, "out".to_string(), h_idx, "h_in".to_string())?;

    println!("Built tensor network with {} tensors and {} bonds", 2, 1);
    println!();

    Ok(())
}

fn demo_circuit_compression() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Circuit Compression ---");

    // Create a circuit with repetitive structure
    let mut circuit = Circuit::<4>::new();

    // Add many gates
    for i in 0..3 {
        circuit.add_gate(Hadamard { target: QubitId(i) })?;
    }

    for i in 0..3 {
        circuit.add_gate(CNOT {
            control: QubitId(i),
            target: QubitId(i + 1),
        })?;
    }

    for i in 0..4 {
        circuit.add_gate(T { target: QubitId(i) })?;
    }

    for i in (1..4).rev() {
        circuit.add_gate(CNOT {
            control: QubitId(i - 1),
            target: QubitId(i),
        })?;
    }

    println!("Original circuit: {} gates", circuit.num_gates());

    // Compress using tensor networks
    let compressor = TensorNetworkCompressor::new(16); // max bond dimension
    let compressed = compressor.compress(&circuit)?;

    println!(
        "Compression ratio: {:.2}%",
        compressed.compression_ratio() * 100.0
    );

    // Check fidelity
    let fidelity = compressed.fidelity(&circuit)?;
    println!("Fidelity with original: {:.6}", fidelity);

    println!();
    Ok(())
}

fn demo_mps_representation() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Matrix Product State Representation ---");

    // Create a circuit that generates an interesting entangled state
    let mut circuit = Circuit::<6>::new();

    // Create W state: (|100000⟩ + |010000⟩ + |001000⟩ + |000100⟩ + |000010⟩ + |000001⟩)/√6
    circuit.add_gate(Hadamard { target: QubitId(0) })?;
    circuit.add_gate(RotationZ {
        target: QubitId(0),
        theta: std::f64::consts::PI / 3.0,
    })?;

    for i in 0..5 {
        circuit.add_gate(CNOT {
            control: QubitId(i),
            target: QubitId(i + 1),
        })?;
    }

    println!("Created circuit for W state preparation");

    // Convert to MPS
    let mps = MatrixProductState::from_circuit(&circuit)?;
    println!("Converted to MPS representation");

    // Compress with different bond dimensions
    let bond_dims = vec![2, 4, 8, 16];

    for &max_bond in &bond_dims {
        let mut mps_copy = MatrixProductState::from_circuit(&circuit)?;
        mps_copy.compress(max_bond, 1e-10)?;

        // In a real implementation, would calculate actual compression metrics
        println!("Max bond dimension {}: compression successful", max_bond);
    }

    println!();
    Ok(())
}

fn demo_compression_methods() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Different Compression Methods ---");

    let mut circuit = Circuit::<5>::new();

    // Build a deep circuit
    for _ in 0..5 {
        for i in 0..5 {
            circuit.add_gate(Hadamard { target: QubitId(i) })?;
        }
        for i in 0..4 {
            circuit.add_gate(CNOT {
                control: QubitId(i),
                target: QubitId(i + 1),
            })?;
        }
    }

    println!("Built deep circuit with {} gates", circuit.num_gates());

    // Test different compression methods
    let methods = vec![
        CompressionMethod::SVD,
        CompressionMethod::DMRG,
        CompressionMethod::TEBD,
    ];

    for method in methods {
        let compressor = TensorNetworkCompressor::new(32).with_method(method.clone());

        let compressed = compressor.compress(&circuit)?;

        println!("\n{:?} compression:", method);
        println!(
            "  Compression ratio: {:.2}%",
            compressed.compression_ratio() * 100.0
        );

        // Try to decompress
        let decompressed = compressed.decompress()?;
        println!("  Decompressed to {} gates", decompressed.num_gates());
    }

    println!();
    Ok(())
}

fn demo_tensor_contraction() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Tensor Contraction Optimization ---");

    // Create a circuit with specific structure
    let mut circuit = Circuit::<4>::new();

    // Layer 1: Single-qubit gates
    for i in 0..4 {
        circuit.add_gate(Hadamard { target: QubitId(i) })?;
    }

    // Layer 2: Entangling gates
    circuit.add_gate(CNOT {
        control: QubitId(0),
        target: QubitId(1),
    })?;
    circuit.add_gate(CNOT {
        control: QubitId(2),
        target: QubitId(3),
    })?;

    // Layer 3: Cross entangling
    circuit.add_gate(CNOT {
        control: QubitId(1),
        target: QubitId(2),
    })?;

    // Convert to tensor network
    let converter = CircuitToTensorNetwork::<4>::new()
        .with_max_bond_dim(8)
        .with_tolerance(1e-12);

    let tn = converter.convert(&circuit)?;

    println!("Converted circuit to tensor network");
    println!("Network has {} tensors", circuit.num_gates());

    // Contract the network
    let result = tn.contract_all()?;
    println!("Contracted to single tensor of rank {}", result.rank());

    println!();
    Ok(())
}

pub fn size(&self) -> usize

Get the total number of elements

Examples found in repository

examples/tensor_network_demo.rs (line 33)

fn demo_basic_tensor_network() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Basic Tensor Network Construction ---");

    // Create simple tensors
    let identity = Tensor::identity(2, "in".to_string(), "out".to_string());
    println!(
        "Created identity tensor: rank={}, size={}",
        identity.rank(),
        identity.size()
    );

    // Create Hadamard tensor
    let h_data = vec![
        C64::new(1.0 / 2.0_f64.sqrt(), 0.0),
        C64::new(1.0 / 2.0_f64.sqrt(), 0.0),
        C64::new(1.0 / 2.0_f64.sqrt(), 0.0),
        C64::new(-1.0 / 2.0_f64.sqrt(), 0.0),
    ];
    let h_tensor = Tensor::new(
        h_data,
        vec![2, 2],
        vec!["h_in".to_string(), "h_out".to_string()],
    );

    // Build tensor network
    let mut tn = TensorNetwork::new();
    let id_idx = tn.add_tensor(identity);
    let h_idx = tn.add_tensor(h_tensor);

    // Connect tensors
    tn.add_bond(id_idx, "out".to_string(), h_idx, "h_in".to_string())?;

    println!("Built tensor network with {} tensors and {} bonds", 2, 1);
    println!();

    Ok(())
}

pub fn contract( &self, other: &Tensor, self_idx: &str, other_idx: &str, ) -> QuantRS2Result<Tensor>

Contract two tensors along specified indices

pub fn reshape(&mut self, new_shape: Vec<usize>) -> QuantRS2Result<()>

Reshape the tensor

Trait Implementations

impl Clone for Tensor

fn clone(&self) -> Tensor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Tensor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.