Struct CausalTensorTrainOperator 

pub struct CausalTensorTrainOperator<T: ConjugateScalar> { /* private fields */ }

A matrix-product operator (MPO) over the same site structure as a CausalTensorTrain.

A linear operator M[(i₀,j₀),…,(i_{d-1},j_{d-1})] is stored as a chain of rank-4 cores W_k of shape [r_k, n_out_k, n_in_k, r_{k+1}], boundary bonds r₀ = r_d = 1. It maps a train over the input dimensions to a train over the output dimensions.

The operator carries a round_policy Truncation used by its Arrow realization (run = apply-then-round), so EndoArrow iteration is a bounded time-march. The explicit apply/compose/round methods take their own truncation and ignore this field.

Implementations

impl<T: ConjugateScalar> CausalTensorTrainOperator<T>

pub fn cores(&self) -> &[CausalTensor<T>]

The cores, in order; core k has shape [r_k, n_out_k, n_in_k, r_{k+1}].

pub fn order(&self) -> usize

The number of sites.

pub fn out_dims(&self) -> &[usize]

The output physical dimensions.

pub fn in_dims(&self) -> &[usize]

The input physical dimensions.

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

The interior bond dimensions [r_1, …, r_{order-1}].

pub fn max_bond(&self) -> usize

The largest bond dimension over the whole operator (at least 1).

pub fn round_policy(&self) -> &Truncation<<T as ConjugateScalar>::Real>

The truncation used by the Arrow::run realization.

impl<T> CausalTensorTrainOperator<T>

where T: ConjugateScalar,

pub fn from_cores( cores: Vec<CausalTensor<T>>, ) -> Result<Self, CausalTensorError>

Builds an operator from an explicit chain of rank-4 cores, validating the bond structure.

Errors

• CausalTensorError::EmptyTensor if cores is empty or any core has a zero dimension.
• CausalTensorError::DimensionMismatch if any core is not 4-dimensional.
• CausalTensorError::BondDimensionMismatch if the boundary bonds are not 1 or adjacent cores disagree on the shared bond.

pub fn identity(dims: &[usize]) -> Self

The identity operator on the given physical dimensions: apply(identity, x) = x.

pub fn from_dense( dense: &CausalTensor<T>, out_dims: &[usize], in_dims: &[usize], trunc: &Truncation<<T as ConjugateScalar>::Real>, ) -> Result<Self, CausalTensorError>

Factors a dense operator into an MPO via operator TT-SVD.

dense must be in site-interleaved layout [out_0, in_0, …, out_{d-1}, in_{d-1}].

Errors

• CausalTensorError::ShapeMismatch if dense’s shape does not match the interleaved out_dims/in_dims.
• Propagates SVD/reshape errors.

pub fn add(&self, other: &Self) -> Result<Self, CausalTensorError>

Sums two operators on the same physical dimensions: (a.add(b))·x = a·x + b·x.

The operators form an algebra — this completes it alongside compose (operator product) and scale. Realized as the tensor-train sum of the combined-index views, so the bond dimensions add (r ← rₐ + r_b); call round afterwards to recompress (e.g. assembling a finite-difference Laplacian (S₊ + S₋ − 2·I)/Δx² from shift operators).

Errors

CausalTensorError::ShapeMismatch if the operators disagree on input or output dimensions.

pub fn scale(&self, s: T) -> Self

Scales the operator by a scalar: (a.scale(s))·x = s·(a·x) (exact, rank-preserving).

pub fn neg(&self) -> Self

Negates the operator (the additive inverse): (a.neg())·x = −(a·x).

pub fn sub(&self, other: &Self) -> Result<Self, CausalTensorError>

Difference of two operators: (a.sub(b))·x = a·x − b·x. Completes the additive group alongside add/neg (e.g. a centered first difference (S₊ − S₋)/2Δx from two shift operators).

Errors

CausalTensorError::ShapeMismatch if the operators disagree on input or output dimensions.

pub fn with_rounding( self, trunc: Truncation<<T as ConjugateScalar>::Real>, ) -> Self

Sets the rounding policy used by the Arrow::run realization.

Trait Implementations

impl<T> Arrow for CausalTensorTrainOperator<T>

where T: ConjugateScalar,

type In = CausalTensorTrain<T>

The input object the arrow consumes.

type Out = CausalTensorTrain<T>

The output object the arrow produces.

fn run(&self, input: Self::In) -> Self::Out

Apply the arrow to an input.

fn compose<G>(self, g: G) -> Compose<Self, G>

where Self: Sized, G: Arrow<In = Self::Out>,

Sequential composition f >>> g: run self, then g on its output.

fn first<C>(self) -> First<Self, C>

where Self: Sized,

first: lift A → B to (A, C) → (B, C), passing the second component through.

fn second<C>(self) -> Second<Self, C>

where Self: Sized,

second: lift A → B to (C, A) → (C, B), passing the first component through.

fn split<G>(self, g: G) -> Split<Self, G>

where Self: Sized, G: Arrow,

The monoidal product ***: run self and g in parallel on a pair — (A, C) → (B, D) from self: A → B and g: C → D.

fn fanout<G>(self, g: G) -> Fanout<Self, G>

where Self: Sized, G: Arrow<In = Self::In>, Self::In: Clone,

Fanout &&&: feed one input to two arrows — A → (B, C) from self: A → B and g: A → C. Requires In: Clone.

fn left<C>(self) -> Left<Self, C>

where Self: Sized,

left: lift A → B to Either<A, C> → Either<B, C>, passing a Right value through (the ⊕ twin of first; Hughes 2000 §5).

fn right<C>(self) -> Right<Self, C>

where Self: Sized,

right: lift A → B to Either<C, A> → Either<C, B>, passing a Left value through (the ⊕ twin of second).

fn choice<G>(self, g: G) -> Choice<Self, G>

where Self: Sized, G: Arrow,

The coproduct sum +++: route each summand to its own arrow — Either<A, C> → Either<B, D> (the ⊕ twin of split).

fn fanin<G>(self, g: G) -> Fanin<Self, G>

where Self: Sized, G: Arrow<Out = Self::Out>,

Fanin |||: the coproduct elimination — both branches converge on one output type, Either<A, C> → B (the ⊕ twin of fanout, with no Clone needed: a sum routes, it never copies).

impl<T: Clone + ConjugateScalar> Clone for CausalTensorTrainOperator<T>

fn clone(&self) -> CausalTensorTrainOperator<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for CausalTensorTrainOperator<T>

where T: ConjugateScalar + Debug, <T as ConjugateScalar>::Real: Debug,

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

Formats the value using the given formatter.

impl<T: PartialEq + ConjugateScalar> PartialEq for CausalTensorTrainOperator<T>

fn eq(&self, other: &CausalTensorTrainOperator<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialEq + ConjugateScalar> StructuralPartialEq for CausalTensorTrainOperator<T>

impl<T> TensorTrainOperator<T> for CausalTensorTrainOperator<T>

where T: ConjugateScalar,

fn apply( &self, state: &CausalTensorTrain<T>, trunc: &Truncation<<T as ConjugateScalar>::Real>, ) -> Result<CausalTensorTrain<T>, CausalTensorError>

Applies the operator to a state train (MPO · MPS), then rounds to trunc.

fn compose( &self, other: &Self, trunc: &Truncation<<T as ConjugateScalar>::Real>, ) -> Result<Self, CausalTensorError>

Composes two operators (MPO · MPO, self after other is not implied — this is self ∘ other acting as self(other(·))), then rounds to trunc.

fn round( &self, trunc: &Truncation<<T as ConjugateScalar>::Real>, ) -> Result<Self, CausalTensorError>

Recompresses the operator to trunc.

fn transpose(&self) -> Self

The transpose operator (swaps the input and output physical legs of every core).

fn to_dense(&self) -> Result<CausalTensor<T>, CausalTensorError>

Contracts the operator to a dense tensor of shape [out_0, in_0, out_1, in_1, …, out_{d-1}, in_{d-1}] (site-interleaved).