Struct ProjectedOperator 

pub struct ProjectedOperator<T, V>
where
    T: TensorLike,
    V: Clone + Hash + Eq + Send + Sync + Debug,
{
    pub operator: TreeTN<T, V>,
    pub envs: EnvironmentCache<T, V>,
    pub input_mapping: Option<HashMap<V, IndexMapping<T::Index>>>,
    pub output_mapping: Option<HashMap<V, IndexMapping<T::Index>>>,
}

ProjectedOperator: Manages 3-chain environments for operator application.

This computes <psi|H|v> 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)
  - operator tensor at `from`
  - ket tensor at `from`
  - all child environments (edges pointing away from `to`)

This forms a “3-chain” sandwich: <bra| H |ket> contracted over all nodes except the open region.

Fields

operator: TreeTN<T, V>

The operator H

envs: EnvironmentCache<T, V>

Environment cache

input_mapping: Option<HashMap<V, IndexMapping<T::Index>>>

Input index mapping (true site index -> MPO’s internal input index) Used when MPO has internal indices different from state’s site indices.

output_mapping: Option<HashMap<V, IndexMapping<T::Index>>>

Output index mapping (true site index -> MPO’s internal output index)

Implementations

impl<T, V> ProjectedOperator<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(operator: TreeTN<T, V>) -> Self

Create a new ProjectedOperator.

pub fn with_index_mappings( operator: TreeTN<T, V>, input_mapping: HashMap<V, IndexMapping<T::Index>>, output_mapping: HashMap<V, IndexMapping<T::Index>>, ) -> Self

Create a new ProjectedOperator with index mappings from a LinearOperator.

The mappings define how state’s site indices relate to MPO’s internal indices. This is required when the MPO uses internal indices (s_in_tmp, s_out_tmp) that differ from the state’s site indices.

pub fn apply<NT: NetworkTopology<V>>( &mut self, v: &T, region: &[V], ket_state: &TreeTN<T, V>, bra_state: &TreeTN<T, V>, topology: &NT, ) -> Result<T>

Apply the operator to a local tensor: compute H|v⟩ at the current position.

If index mappings are set (via with_index_mappings), this method:

1. Transforms input v’s site indices using unique temp indices (avoids duplicate IDs)
2. Contracts with MPO tensors and environment tensors
3. Transforms result’s temp output indices back to true site indices
4. Replaces bra-side boundary bonds with ket-side so output lives in same space as v
5. Permutes result to v’s index order so output structure matches input

Arguments

• v - The local tensor to apply the operator to
• region - The nodes in the open region
• ket_state - The current state |ket⟩ (used for ket in environment computation)
• bra_state - The reference state ⟨bra| (used for bra in environment computation) For V_in = V_out, this is the same as ket_state. For V_in ≠ V_out, this should be a state in V_out.
• topology - Network topology for traversal

Returns

The result of applying H to v: H|v⟩, with same index set and order as v.

pub fn local_dimension(&self, region: &[V]) -> usize

Compute the local dimension (size of the local Hilbert space).

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

Invalidate caches affected by updates to the given region.