Enum NestedEinsum 

pub enum NestedEinsum<L: Label> {
    Leaf {
        tensor_index: usize,
    },
    Node {
        args: Vec<NestedEinsum<L>>,
        eins: EinCode<L>,
    },
}

A binary tree representing the contraction order for an einsum.

Each internal node represents a contraction of its two children, and each leaf represents an input tensor.

Example

use omeco::{EinCode, NestedEinsum};

// Create leaves for input tensors
let leaf0 = NestedEinsum::<char>::leaf(0);
let leaf1 = NestedEinsum::<char>::leaf(1);

// Contract tensors 0 and 1
let contraction = EinCode::new(
    vec![vec!['i', 'j'], vec!['j', 'k']],
    vec!['i', 'k']
);
let tree = NestedEinsum::node(vec![leaf0, leaf1], contraction);

assert!(tree.is_binary());

Variants

Leaf

A leaf node referencing an input tensor by index.

Fields

tensor_index: usize

Index of the input tensor (0-indexed)

Node

An internal node representing a contraction.

Fields

args: Vec<NestedEinsum<L>>

Child nodes to contract

eins: EinCode<L>

The einsum operation for this contraction

Implementations

impl<L: Label> NestedEinsum<L>

pub fn leaf(tensor_index: usize) -> Self

Create a leaf node for an input tensor.

pub fn node(args: Vec<NestedEinsum<L>>, eins: EinCode<L>) -> Self

Create an internal node for a contraction.

pub fn is_leaf(&self) -> bool

Check if this node is a leaf.

pub fn tensor_index(&self) -> Option<usize>

Get the tensor index if this is a leaf node.

pub fn is_binary(&self) -> bool

Check if the tree is strictly binary (each internal node has exactly 2 children).

pub fn node_count(&self) -> usize

Count the total number of nodes in the tree.

pub fn leaf_count(&self) -> usize

Count the number of leaf nodes (input tensors).

pub fn leaf_indices(&self) -> Vec<usize>

Get all leaf tensor indices in depth-first order.

pub fn output_labels(&self, input_labels: &[Vec<L>]) -> Vec<L>

Get the output labels for this subtree.

Requires the original input tensor labels to compute leaf outputs.

pub fn depth(&self) -> usize

Get the depth of the tree (longest path from root to leaf).

pub fn to_eincode(&self, input_labels: &[Vec<L>]) -> EinCode<L>

Convert a NestedEinsum back to a flat EinCode.

This “flattens” the contraction tree by collecting all the input tensors in order and using the final output labels from the root.

Arguments

• input_labels - The original labels for each input tensor, indexed by tensor_index

Returns

A flat EinCode representing the same computation

Example

use omeco::{EinCode, NestedEinsum};

let original_ixs = vec![vec!['i', 'j'], vec!['j', 'k']];
let original_output = vec!['i', 'k'];
let code = EinCode::new(original_ixs.clone(), original_output.clone());

// After optimization
let nested = omeco::optimize_code(&code, &omeco::uniform_size_dict(&code, 2), &omeco::GreedyMethod::default()).unwrap();

// Convert back to flat EinCode
let flat = nested.to_eincode(&original_ixs);

assert_eq!(flat.ixs, original_ixs);
assert_eq!(flat.iy, original_output);

pub fn is_path_decomposition(&self) -> bool

Check if this tree forms a valid path decomposition.

A path decomposition is a binary tree where each internal node has at most one internal child (the other must be a leaf). This forms a linear “path” structure that guarantees bounded treewidth.

Returns

true if the tree is a valid path decomposition, false otherwise.

Example

use omeco::{EinCode, NestedEinsum};

// Valid path decomposition: ((leaf0, leaf1), leaf2)
let leaf0 = NestedEinsum::<char>::leaf(0);
let leaf1 = NestedEinsum::<char>::leaf(1);
let leaf2 = NestedEinsum::<char>::leaf(2);

let eins1 = EinCode::new(vec![vec!['i', 'j'], vec!['j', 'k']], vec!['i', 'k']);
let node1 = NestedEinsum::node(vec![leaf0, leaf1], eins1);

let eins2 = EinCode::new(vec![vec!['i', 'k'], vec!['k', 'l']], vec!['i', 'l']);
let path_tree = NestedEinsum::node(vec![node1, leaf2], eins2);

assert!(path_tree.is_path_decomposition());

Trait Implementations

impl<L: Clone + Label> Clone for NestedEinsum<L>

fn clone(&self) -> NestedEinsum<L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Debug + Label> Debug for NestedEinsum<L>

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

Formats the value using the given formatter.

impl<'de, L> Deserialize<'de> for NestedEinsum<L>

where L: Deserialize<'de> + Label,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<L: PartialEq + Label> PartialEq for NestedEinsum<L>

fn eq(&self, other: &NestedEinsum<L>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<L> Serialize for NestedEinsum<L>

where L: Serialize + Label,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<L: Eq + Label> Eq for NestedEinsum<L>

impl<L: Label> StructuralPartialEq for NestedEinsum<L>