GitHub

State representation

TimeEvolutionPEPO.AbstractPEPO — Type
abstract type AbstractPEPO{G, PType<:(TensorKit.AbstractTensorMap{T, S, N₁, 4} where {N₁, S, T})} <: TensorRenormalizationGroups.AbstractUnitCell{G, PType<:(TensorKit.AbstractTensorMap{T, S, N₁, 4} where {N₁, S, T}), Array{PType<:(TensorKit.AbstractTensorMap{T, S, N₁, 4} where {N₁, S, T}), 2}}

Abstract supertype of all PEPO-like objects.

source
TimeEvolutionPEPO.PEPO — Type
struct PEPO{G, PType<:(TensorKit.AbstractTensorMap{T, S, N₁, 4} where {N₁, S, T}), CType} <: AbstractPEPO{G, PType<:(TensorKit.AbstractTensorMap{T, S, N₁, 4} where {N₁, S, T})}

Concrete type representing a projected-entangled pair operator in the symmetric gauge with with associated bond weights accessible with the weights function. Each tensor is defined on the tensor space ket * bra' ← east * south * west' * north', and has the following structure (the ket and bra spaces are indices 1 and 2 respectively):

                   ⋮                 ⋮
                   ▲                 ▲
                   │                 │
                   │                 │
               ┌───┴───┐         ┌───┴───┐
               │   6   │         │   6   │
     ⋯ ◄───────┤5 A₁₁ 3├─────────┤5 A₂₁ 3│◄─────── ⋯
               │   4   │         │   4   │
               └───┬───┘         └───┬───┘
                   │                 │
                   │                 │
                   │                 │
               ┌───┴───┐         ┌───┴───┐
               │   6   │         │   6   │
     ⋯ ◄───────┤5 A₁₂ 3├─────────┤5 A₂₂ 3│◄─────── ⋯
               │   4   │         │   4   │
               └───────┘         └───────┘
                   ▲                 ▲
                   │                 │
                   │                 │
                   ⋮                 ⋮

where Aᵢⱼ refers to tensor obtained by indexing pepo[i,j].

See also: AbstractPEPO, ThermalState, and bondweights

Fields

  • data: The unit-cell of tensors defining the projected entangled pair operator with bond weights absorbed.
  • weights: Bond weights on each virtual bond. Note, the sqrt of each weight are assumed to be pre absorbed in to the tensors in data.

Constructors

The following constructors can also be called with PEPO{G} where {G<:AbstractUnitCellGeometry} to dictate the unit-cell geometry of the output PEPO object. This will error if any of the input arguments specify a unit-cell geometry the conflicts with G.

PEPO(
    init::Union{T, AbstractMatrix{T}}, 
    phys::Union{S, AbstractMatrix{S}}, 
    east::Union{S, AbstractMatrix{S}},  
    [south::Union{S, AbstractMatrix{S}} = east]
) where {T, S<:Union{Int, IndexSpace}}

The type T can be one of the following:

  • NTuple{3, Float64}: a spin-1/2 Bloch-vector
  • ThermalState: the infinite temperature thermal density matrix
  • Matrix{<:Number}: a density matrix
  • Array{6, <:Number}: a tensor defining the pepo tensor for each lattice site

Similarly, phys, east and south can be of type Union{S, AbstractMatrix{S} where S<:Union{Int, IndexSpace}. The size of the unit-cell of the resulting PEPO object is determined via promote_shape automatically through an internal call to broadcast. 

PEPO(data::Union{T,AbstractMatrix{T}}) where {T<:TensorMap}

Construct a PEPO with with each tensor given by data.

source
TimeEvolutionPEPO.bondweights — Function
bondweights(
    pepo::PEPO
) -> UnitCellBonds{G, CType, Array{Tuple{CType, CType}, 2}} where {G, CType}

Return the bond weights of associated with projected etangled pair operator. Note these are already aborbed the state.

See also: PEPO, bondentropy

source
TimeEvolutionPEPO.bondentropy — Function
bondentropy(
    w::TensorKit.AbstractTensorMap;
    normalized
) -> Any

Compute the bond entropy of bond weight w. If normalised = true, then also divide the result by log(D) where D is the dimension of the codomain/domain of w.

See also: PEPO, bondweights

source
TimeEvolutionPEPO.expandspace — Function
expandspace(pepo::AbstractPEPO, space::IndexSpace)

Promote the virtual bond spaces of pepo to space. This function can be used to increase the bond dimension of pepo.

source
TimeEvolutionPEPO.subpepo — Function
subpepo(pepo::PEPO, x, y; weights=false) -> PEPO

Return a PEPO over the smaller unit cell specified by indices x and y. If weights=true, the PEPO is constructed with the weights of the chosen lattice sites, otherwise they are initilised to identities. Arguments x and y can be of type Union{Int, UnitRange{Int}, Colon}.

source