Struct ProjectedState 

pub struct ProjectedState<T, V>
where
    T: TensorLike,
    V: Clone + Hash + Eq + Send + Sync + Debug,
{
    pub rhs: TreeTN<T, V>,
    pub envs: EnvironmentCache<T, V>,
}

ProjectedState: Manages 2-chain environments for RHS computation.

This computes <b|x_local> for each local region during the sweep.

For Tree Tensor Networks, the environment is computed by contracting all tensors outside the “open region” into environment tensors. The open region consists of nodes being updated in the current sweep step.

Structure

For each edge (from, to) pointing towards the open region, we cache:

env[(from, to)] = contraction of:
  - bra tensor at `from` (conjugated RHS)
  - ket tensor at `from` (current solution)
  - all child environments (edges pointing away from `to`)

This forms a “2-chain” overlap: <b|x> contracted over all nodes except the open region.

Fields

rhs: TreeTN<T, V>

The RHS state |b⟩

envs: EnvironmentCache<T, V>

Environment cache

Implementations

impl<T, V> ProjectedState<T, V>

where T: TensorLike, <T::Index as IndexLike>::Id: Clone + Hash + Eq + Ord + Debug + Send + Sync + 'static, V: Clone + Hash + Eq + Ord + Send + Sync + Debug,

pub fn new(rhs: TreeTN<T, V>) -> Self

Create a new ProjectedState.

pub fn local_constant_term<NT: NetworkTopology<V>>( &mut self, region: &[V], reference_state: &TreeTN<T, V>, topology: &NT, ) -> Result<T>

Compute the local constant term (local RHS) for the given region.

This returns the local RHS tensors contracted with environments.

For the square case, the reference_state is used as the bra (conjugated), and rhs is used as the ket, i.e. environments are constructed for <ref|b>.

Arguments

• region - The nodes in the local update region
• reference_state - The current solution state (used as reference for environments)
• topology - The network topology

pub fn invalidate<NT: NetworkTopology<V>>( &mut self, region: &[V], topology: &NT, )

Invalidate caches affected by updates to the given region.