Struct TensorNetwork 

pub struct TensorNetwork {
    pub tensors: HashMap<usize, Tensor>,
    pub connections: Vec<(TensorIndex, TensorIndex)>,
    pub num_qubits: usize,
    pub max_bond_dimension: usize,
    pub detected_circuit_type: CircuitType,
    pub using_qft_optimization: bool,
    pub using_qaoa_optimization: bool,
    pub using_linear_optimization: bool,
    pub using_star_optimization: bool,
    /* private fields */
}

Tensor network representation of a quantum circuit

Fields

tensors: HashMap<usize, Tensor>

Collection of tensors in the network

connections: Vec<(TensorIndex, TensorIndex)>

Connections between tensor indices

num_qubits: usize

Number of physical qubits

max_bond_dimension: usize

Maximum bond dimension for approximations

detected_circuit_type: CircuitType

Detected circuit type for optimization

using_qft_optimization: bool

Whether QFT optimization is enabled

using_qaoa_optimization: bool

Whether QAOA optimization is enabled

using_linear_optimization: bool

Whether linear optimization is enabled

using_star_optimization: bool

Whether star optimization is enabled

Implementations

impl TensorNetwork

pub fn new(num_qubits: usize) -> Self

Create a new empty tensor network

pub fn add_tensor(&mut self, tensor: Tensor) -> usize

Add a tensor to the network

pub fn connect(&mut self, idx1: TensorIndex, idx2: TensorIndex) -> Result<()>

Connect two tensor indices

pub fn get_neighbors(&self, tensor_id: usize) -> Vec<usize>

Get all tensors connected to the given tensor

pub fn contract_all(&self) -> Result<Complex64>

Contract all tensors to compute the final amplitude

pub fn total_elements(&self) -> usize

Get the total number of elements across all tensors

pub fn memory_usage(&self) -> usize

Estimate memory usage in bytes

pub fn find_optimal_contraction_order(&self) -> Result<Vec<usize>>

Find optimal contraction order using dynamic programming

pub fn find_lowest_cost_pair( &self, tensors: &[Tensor], ) -> Result<(usize, usize, f64)>

Find the pair of tensors with lowest contraction cost

pub fn estimate_contraction_cost( &self, tensor_a: &Tensor, tensor_b: &Tensor, ) -> f64

Estimate the computational cost of contracting two tensors

pub fn contract_tensor_pair( &self, tensor_a: &Tensor, tensor_b: &Tensor, ) -> Result<Tensor>

Contract two tensors optimally

pub fn set_basis_state_boundary(&mut self, basis_state: usize) -> Result<()>

Set boundary conditions for a specific computational basis state

pub fn apply_gate( &mut self, gate_tensor: Tensor, target_qubit: usize, ) -> Result<()>

Apply a single-qubit gate to the tensor network

pub fn apply_two_qubit_gate( &mut self, gate_tensor: Tensor, control_qubit: usize, target_qubit: usize, ) -> Result<()>

Apply a two-qubit gate to the tensor network

Trait Implementations

impl Clone for TensorNetwork

fn clone(&self) -> TensorNetwork

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TensorNetwork

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

Formats the value using the given formatter.

impl Display for TensorNetwork

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

Formats the value using the given formatter.