Library documentation

mutable struct ATRG{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}} <: TNRScheme{E, S}

Anisotropic Tensor Renormalization Group

Constructors

ATRG(T)

Running the algorithm

run!(::ATRG, trunc::TruncationStrategy, stop::Stopcrit[, finalizer=default_Finalizer, finalize_beginning=true, verbosity=1])

Each step rescales the lattice by a (linear) factor of √2

Fields

• T::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Central tensor

References

• Adachi et. al. Phys. Rev. B 102 (2020)

mutable struct ATRG_3D{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 4}} <: TNRScheme{E, S}

3D Anisotropic Tensor Renormalization Group

Constructors

ATRG_3D(T)

Running the algorithm

run!(::ATRG_3D, trunc::TruncationStrategy, stop::Stopcrit[, finalizer=defualt_Finalizer, finalize_beginning=true,verbosity=1])

Each step rescales the lattice by a (linear) factor of 2

Fields

• T::TensorKit.AbstractTensorMap{E, S, 2, 4} where {E, S}: Central tensor

References

• Adachi et. al. Phys. Rev. B 102 (2020)

mutable struct BTRG{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}, BT<:TensorKit.AbstractTensorMap{E, S, 1, 1}} <: TNRScheme{E, S}

Bond-weighted Tensor Renormalization Group

Constructors

BTRG(T [, k=-1/2])

Running the algorithm

run!(::BTRG, trunc::TruncationStrategy, stop::Stopcrit[, finalizer=default_Finalizer, finalize_beginning=true, verbosity=1])

Each step rescales the lattice by a (linear) factor of √2

Fields

• T::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Central tensor

• S1::TensorKit.AbstractTensorMap{E, S, 1, 1} where {E, S}: Bond tensor on vertical bonds

• S2::TensorKit.AbstractTensorMap{E, S, 1, 1} where {E, S}: Bond tensor on horizontal bonds

• k::Float64: Bond weight exponent

References

• Adachi et. al. Phys. Rev. B 105 (2022)

CFTData{E, I} where {E, I}

A struct to hold conformal data extracted from a TNR scheme.

Constructors

CFTData(scheme::TNRScheme; kwargs...)
CFTData(TA::TensorMap{E, S, 2, 2}; kwargs...)
CFTData(TA::TensorMap{E, S, 2, 2}, TB::TensorMap{E, S, 2, 2}; kwargs...)

Fields

- `central_charge::Union{E, Missing}`: The central charge of the CFT. Will be `nothing` if not calculated.
- `scaling_dimensions::TensorKit.SectorVector{E, I}`: The scaling dimensions of the CFT, organized in a `TensorKit.SectorVector` where the sectors correspond to different spin sectors (or other quantum numbers) and the data contains the scaling dimensions within those sectors

mutable struct CTM{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}, TC<:TensorKit.AbstractTensorMap{E, S, 1, 1}, TE<:TensorKit.AbstractTensorMap{E, S, 2, 1}} <: TNRScheme{E, S}

Corner Transfer Matrix Renormalization Group (one-site environment)

Constructors

CTM(T[, bc=ones, bc_free=false])

Running the algorithm

run!(::CTM, trunc::TruncationStrategy, criterion::maxiter[, conv_criterion=1.0e-8, verbosity=1])

Fields

• T::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}

• Ctl::TensorKit.AbstractTensorMap{E, S, 1, 1} where {E, S}

• Ctr::TensorKit.AbstractTensorMap{E, S, 1, 1} where {E, S}

• Cbr::TensorKit.AbstractTensorMap{E, S, 1, 1} where {E, S}

• Cbl::TensorKit.AbstractTensorMap{E, S, 1, 1} where {E, S}

• El::TensorKit.AbstractTensorMap{E, S, 2, 1} where {E, S}

• Eb::TensorKit.AbstractTensorMap{E, S, 2, 1} where {E, S}

• Et::TensorKit.AbstractTensorMap{E, S, 2, 1} where {E, S}

• Er::TensorKit.AbstractTensorMap{E, S, 2, 1} where {E, S}

    ┌───┐ ┌──┐ ┌───┐
    │Ctl├─┤Et├─┤Ctr│
    └─┬─┘ └┬─┘ └─┬─┘
    ┌─┼─┐ ┌┼─┐ ┌─┼─┐
    │El ├─┤T ├─┤Er │
    └─┬─┘ └┬─┘ └─┬─┘
    ┌─┼─┐ ┌┼─┐ ┌─┼─┐
    │Cbl├─┤Eb├─┤Cbr│
    └───┘ └──┘ └───┘

References

• Baxter Physica A 106(1) (1981)
• Nishino & Okunishi J. Phys. Soc. Jpn. 65 (1996)

mutable struct CTM_honeycomb{E, S}

Corner Transfer Matrix Renormalization Group for the honeycomb lattice

Constructors

CTM_honeycomb(T)
CTM_honeycomb(T, [, symmetrize=false])

     (120°)
        ╲ 
         ╲ 
          ╲ 
           T -----(0°)
           ╱
          ╱
         ╱
      (240°)

CTM can be called with a (2, 1) tensor, where the directions are (240°, 0°, 120°) clockwise with respect to the positive x-axis. In the flipped arrow convention, the arrows point from (120°) to (240°, 0°). or with a (0,3) tensor (120°, 0°, 240°) where all arrows point inward (unflipped arrow convention).

Running the algorithm

run!(::CTM, trunc::TruncationStrategy, stop::Stopcrit[, finalize_beginning=true, verbosity=1])

Fields

• A::TensorKit.TensorMap{E, S, 0, 3, A} where {E, S, A<:DenseVector{E}}

• B::TensorKit.TensorMap{E, S, 0, 3, A} where {E, S, A<:DenseVector{E}}

• C::Array{TensorKit.TensorMap{E, S, 1, 1, A} where A<:DenseVector{E}, 1} where {E, S}

• Ta::Array{TensorKit.TensorMap{E, S, 2, 1, A} where A<:DenseVector{E}, 1} where {E, S}

• Tb::Array{TensorKit.TensorMap{E, S, 2, 1, A} where A<:DenseVector{E}, 1} where {E, S}

References

• Nyckees et al. Phys. Rev. E 108.064132 (2023)

mutable struct CTM_triangular{A, S}

Corner Transfer Matrix Renormalization Group for the triangular lattice

Constructors

CTM_triangular(T)
CTM_triangular(T, [, symmetrize=false])

     (120°)     (60°)
        ╲       ╱
         ╲     ╱
          ╲   ╱
(180°)----- T -----(0°)
           ╱ ╲
          ╱   ╲
         ╱     ╲
      (240°) (300°)

CTM can be called with a (3, 3) tensor, where the directions are (180°, 240°, 300°, 120°, 60°, 0°) clockwise with respect to the positive x-axis. In the flipped arrow convention, the arrows point from (120°, 60°, 0°) to (180°, 240°, 300°). or with a (0,6) tensor (120°, 60°, 0°, 300°, 240°, 180°) where all arrows point inward (unflipped arrow convention). The keyword argument symmetrize makes the tensor C6v symmetric when set to true. If symmetrize = false, it checks the symmetry explicitly.

Running the algorithm

run!(::CTM, trunc::TruncationStrategy, stop::Stopcrit[, finalize_beginning=true, verbosity=1])

Fields

• T::TensorKit.TensorMap{A, S, 0, 6, A1} where {A, S, A1<:DenseVector{A}}

• C::Array{TensorKit.TensorMap{A, S, 2, 1, A1} where A1<:DenseVector{A}, 1} where {A, S}

• Ea::Array{TensorKit.TensorMap{A, S, 2, 1, A1} where A1<:DenseVector{A}, 1} where {A, S}

• Eb::Array{TensorKit.TensorMap{A, S, 2, 1, A1} where A1<:DenseVector{A}, 1} where {A, S}

References

• Naumann et al. Phys. Rev. B 113(4) (2026)

mutable struct CorrelationHOTRG{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}}

Simple two-point correlation function for Higher-Order Tensor Renormalization Group

Constructors

CorrelationHOTRG(T, Timp1, Timp2, dist)

Running the algorithm

run!(scheme::CorrelationHOTRG, trunc::TruncationStrategy, niter::stopcrit[, verbosity=1])

Each step rescales the lattice by a (linear) factor of 2

Fields

• Tpure::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Pure Tensor

• Timp1::Union{Nothing, TT} where {E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}}: First type first order impurity tensor (Phase I)

• Timp2::Union{Nothing, TT} where {E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}}: Second type first order impurity tensor (Phase I)

• Timp_final::Union{Nothing, TT} where {E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}}: The final impurity (Phase II & III)

• dist::Int64: Correlation distance (2^dist)

• iter::Int64: Iteration step

References

Piceu J.

struct Finalizer{E}

Finalizer for TNR schemes

Constructors

Finalizer(f!::Function, E::Type)

A Finalizer holds a function f! that is to be applied to a TNR scheme after each step of the algorithm (and at the beginning if specified by run!(;finalize_beginning=true), which is the default behavior). The type parameter E indicates the output type of f!, which is used to create an array of the correct type to hold the outputs.

mutable struct HOTRG{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}} <: TNRScheme{E, S}

Higher-Order Tensor Renormalization Group

Constructors

HOTRG(T)

Running the algorithm

run!(::HOTRG, trunc::TruncationStrategy, stop::Stopcrit[, finalizer=default_Finalizer, finalize_beginning=true, verbosity=1])

Each step rescales the lattice by a (linear) factor of 2

Fields

• T::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Central tensor

References

• Xie et. al. Phys. Rev. B 86 (2012)

mutable struct HOTRG_3D{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 4}} <: TNRScheme{E, S}

3D Higher-Order Tensor Renormalization Group

Constructors

HOTRG_3D(T)

Running the algorithm

run!(::HOTRG_3D, trunc::TruncationStrategy, stop::Stopcrit[, finalizer=default_Finalizer, finalize_beginning=true, verbosity=1])

Each step rescales the lattice by a (linear) factor of 2

Fields

• T::TensorKit.AbstractTensorMap{E, S, 2, 4} where {E, S}: Central tensor

References

• Xie et. al. Phys. Rev. B 86 (2012)

mutable struct ImpurityHOTRG{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}} <: TNRScheme{E, S}

Single impurity method for Higher-Order Tensor Renormalization Group (for 2nd order)

Constructors

ImpurityHOTRG(T, T_imp_order1_1, T_imp_order1_2, T_imp_order2)

Running the algorithm

run!(::ImpurityHOTRG, trunc::TruncationStrategy, stop::Stopcrit[, finalizer=ImpurityHOTRG_Finalizer, finalize_beginning=true, verbosity=1])

Each step rescales the lattice by a (linear) factor of 2

Fields

• T::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Central Tensor

• T_imp_order1_1::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: +1 Type first order impurity tensor

• T_imp_order1_2::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: -1 Type first order impurity tensor

• T_imp_order2::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Second order impurity tensor

References

• Morita et al 10.1016/j.cpc.2018.10.014 (2018)

mutable struct ImpurityTRG{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}} <: TNRScheme{E, S}

Impurity method for Tensor Renormalization Group

Constructors

ImpurityTRG(T, T_imp1, T_imp2, T_imp3, T_imp4)

Running the algorithm

run!(::ImpurityTRG, trunc::TruncationStrategy, stop::Stopcrit[, finalizer=ImpurityTRG_Finalizer, finalize_beginning=true, verbosity=1])

Each step rescales the lattice by a (linear) factor of √2

Fields

• T::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Pure tensor

• T_imp1::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Impurity tensor on lattice site 1

• T_imp2::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Impurity tensor on lattice site 2

• T_imp3::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Impurity tensor on lattice site 3

• T_imp4::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Impurity tensor on lattice site 4

Illustration (with p the pure tensor, and the p fills in the rest of the lattice):

    p   p
    |   |  
p---1---2---p
    |   |
p---4---3---p
    |   |
    p   p

References

• Kadoh et. al. 10.1007/JHEP05(2019)184 (2019)
• Morita et. al. Phys. Rev. B 111 (2025)

struct LoopParameters{A}

Parameters used during LoopTNR. This struct allows the user to control how the linear problem is solved. It also allows the user to turn on nuclear norm regularization.

Fields

• sweeping::TNRKit.stopcrit

• one_loop_init::Bool

• truncentanglement::MatrixAlgebraKit.TruncationStrategy

• krylov::Bool: Use Krylov methods to solve the linear system in loop optimization. Default = false, which uses the backslash operator.

• krylovalg::Any: Default Krylov algorithm is GMRES with maxiter = 250, krylovdim = 128, tol = 1.0e-10, verbosity = 0.

• nuclear_norm::Bool: Use Nuclear Norm Regularisation. Default = false

• ρ::Float64

• ξ_init::Float64

• ξ_min::Float64

mutable struct LoopTNR{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}} <: TNRScheme{E, S}

Loop Optimization for Tensor Network Renormalization

Constructors

LoopTNR(T)
LoopTNR(TA, TB)
LoopTNR(unitcell_2x2::Matrix{T})

Running the algorithm

run!(::LoopTNR, trunc::TruncationStrategy, criterion::stopcrit, parameters::LoopParameters, finalizer::Finalizer[,
          entanglement_criterion::stopcrit, finalize_beginning=true, verbosity=1])

run!(::LoopTNR, trscheme::TruncationStrategy, criterion::stopcrit, parameters::LoopParameters; kwargs...)

run!(::LoopTNR, trscheme::TruncationStrategy, criterion::stopcrit[finalize_beginning=true, verbosity=1])

LoopParameters

See also: LoopParameters This stuct is used to set all internal parameters in LoopTNR. It can also be used to control whether Krylov methods are used (default: false) And whether nuclear norm regularization is used (default: false)

Fields

• TA::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Central tensor on sublattice A

• TB::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: Central tensor on sublattice B

References

• Yang et. al. Phys. Rev. Letters 118 (2017)
• Homma et. al. Phys. Rev. Res. 6 (2024)

LoopTNR(
    unitcell_2x2::Matrix{T},
    trunc::TruncationStrategy,
    loop_condition::LoopParameters
) where {T <: AbstractTensorMap{<:Any, <:Any, 2, 2}}

Initialize LoopTNR using a network with 2 x 2 unit cell, by first performing one round of loop optimization to reduce the network to a bipartite one (without normalization).

mutable struct SLoopTNR{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 4, 0}} <: TNRScheme{E, S}

c4 & inversion symmetric Loop Optimization for Tensor Network Renormalization

Constructors

SLoopTNR(T)
SLoopTNR(TA, TB)

Running the algorithm

run!(::SLoopTNR, trscheme::TruncationStrategy,
          criterion::TNRKit.stopcrit[, finalizer=default_Finalizer, finalize_beginning=true, oneloop=true,
          verbosity=1])

oneloop=true will use disentangled tensors as a starting guess for the optimization.

Fields

• T::TensorKit.AbstractTensor{E, S, 4} where {E, S}: Central tensor

• gradalg::OptimKit.LBFGS: Gradient optimization algorithm

References

• Yang et. al. Phys. Rev. Letters 118 (2017) (Fig. S6)

– CTMRG for A-B sublattice systems

┌────┐ ┌───┐ ┌───┐ ┌────┐ │Ctl1├──┤EtB├──┤EtA├──┤Ctr1│ └─┬──┘ └─┬─┘ └─┬─┘ └─┬──┘ ┌─┼──┐ ┌─┼─┐ ┌─┼─┐ ┌─┼──┐ │ElB ├──┤ A ├──┤ B ├──┤ErA │ └─┬──┘ └─┬─┘ └─┬─┘ └─┬──┘ ┌─┼──┐ ┌─┼─┐ ┌─┼─┐ ┌─┼──┐ │ElA ├──┤ B ├──┤ A ├──┤ErB │ └─┬──┘ └─┬─┘ └─┬─┘ └─┬──┘ ┌─┼──┐ ┌─┼─┐ ┌─┼─┐ ┌─┼──┐ │Cbl1├──┤EbA├──┤EbB├──┤Cbr1│ └────┘ └───┘ └───┘ └────┘

┌────┐ ┌───┐ ┌───┐ ┌────┐ │Ctl2├──┤EtA├──┤EtB├──┤Ctr2│ └─┬──┘ └─┬─┘ └─┬─┘ └─┬──┘ ┌─┼──┐ ┌─┼─┐ ┌─┼─┐ ┌─┼──┐ │ElA ├──┤ B ├──┤ A ├──┤ErB │ └─┬──┘ └─┬─┘ └─┬─┘ └─┬──┘ ┌─┼──┐ ┌─┼─┐ ┌─┼─┐ ┌─┼──┐ │ElB ├──┤ A ├──┤ B ├──┤ErA │ └─┬──┘ └─┬─┘ └─┬─┘ └─┬──┘ ┌─┼──┐ ┌─┼─┐ ┌─┼─┐ ┌─┼──┐ │Cbl2├──┤EbB├──┤EbA├──┤Cbr2│ └────┘ └───┘ └───┘ └────┘

struct TNO{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 4}} <: AbstractArray{TT<:TensorKit.AbstractTensorMap{E, S, 2, 4}, 2}

Matrix-like container for a tensor network operator (TNO) unit cell.

The entries are local operator tensors with two physical indices and four virtual indices. The container behaves like an AbstractMatrix, so it supports size, axes, indexing and iteration.

Constructors

TNO(A::AbstractMatrix{<:TNOTensor})
TNO(A::TNOTensor; unitcell=(1, 1))

Fields

• A::Matrix{TT} where {E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 4}}: Matrix of local TNO tensors over the unit cell.

TNOTensor{E,S}

Type alias for a local tensor-network-operator tensor with two physical legs and four virtual legs, i.e. an AbstractTensorMap{E,S,2,4}.

Following the PEPO convention used in PEPSKit, the local tensor is interpreted as P_out ⊗ P_in <- N ⊗ E ⊗ S ⊗ W.

mutable struct TRG{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}} <: TNRScheme{E, S}

Tensor Renormalization Group

Constructors

TRG(T)

Running the algorithm

run!(::TRG, trunc::TruncationStrategy, stop::Stopcrit[, finalizer=default_Finalizer, finalize_beginning=true, verbosity=1])

Each step rescales the lattice by a (linear) factor of √2

Fields

• T::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}: central tensor

References

• Levin & Nave Phys. Rev. Letters 99(12) (2007)

mutable struct ThermalTNR{E, S} <: TNRScheme{E, S}

Thermal Tensor Network Renormalization on a square-lattice

Constructors

ThermalTNR(A::AbstractMatrix{<:AbstractTensorMap})
ThermalTNR(T::AbstractTensorMap{E, S, 2, 4})

Running the algorithm

run!(::ThermalTNR, A::AbstractMatrix{<:AbstractTensorMap}, trunc::TruncationStrategy, criterion::stopcrit[
          , finalizer=default_Finalizer, finalize_beginning=true, verbosity=1])

Fields

• T::TNRKit.TNO: Internal tensor network operator stored in the current TTNR layer.

References

• Ueda et al. (2025)

mutable struct c3vCTM_honeycomb{A, S}

Corner Transfer Matrix Renormalization Group for the honeycomb lattice

Constructors

c3vCTM_honeycomb(T)
c3vCTM_honeycomb(T, [, symmetrize=false])

     (120°)
        ╲ 
         ╲ 
          ╲ 
           T -----(0°)
           ╱
          ╱
         ╱
      (240°)

CTM can be called with a (2, 1) tensor, where the directions are (240°, 0°, 120°) clockwise with respect to the positive x-axis. In the flipped arrow convention, the arrows point from (120°) to (240°, 0°). or with a (0,3) tensor (120°, 0°, 240°) where all arrows point inward (unflipped arrow convention). The keyword argument symmetrize makes the tensor C6v symmetric when set to true. If symmetrize = false, it checks the symmetry explicitly.

Running the algorithm

run!(::CTM, trunc::TruncationStrategy, stop::Stopcrit[, finalize_beginning=true, verbosity=1])

Fields

• T::TensorKit.TensorMap{A, S, 0, 3, A1} where {A, S, A1<:DenseVector{A}}

• C::TensorKit.TensorMap{A, S, 1, 1, A1} where {A, S, A1<:DenseVector{A}}

• L::TensorKit.TensorMap{A, S, 2, 1, A1} where {A, S, A1<:DenseVector{A}}

• R::TensorKit.TensorMap{A, S, 2, 1, A1} where {A, S, A1<:DenseVector{A}}

References

• Lukin et al. Phys. Rev. B 107.054424 (2023)

mutable struct c4vCTM{A, S, TT<:TensorKit.AbstractTensorMap{A, S, 0, 4}, TC<:TensorKit.AbstractTensorMap{A, S, 1, 1}, TE<:TensorKit.AbstractTensorMap{A, S, 2, 1}} <: TNRScheme{A, S}

C4v symmetric Corner Transfer Matrix Renormalization Group

Constructors

c4vCTM(T)
c4vCTM(T, [, symmetrize=false])

c4vCTM can be called with a (2,2) tensor (West, South, North, East) with the usual arrow conventions (flipped arrow convention), or with a (0,4) tensor (North, East, South, West) (unflipped arrow convention). The keyword argument symmetrize makes the tensor C4v symmetric when set to true. If symmetrize = false, it checks the symmetry explicitly.

Running the algorithm

run!(::c4vCTM, trunc::TruncationStrategy, stop::Stopcrit[, finalize_beginning=true, verbosity=1])

Fields

• T::TensorKit.AbstractTensorMap{A, S, 0, 4} where {A, S}: Central tensor

• C::TensorKit.AbstractTensorMap{A, S, 1, 1} where {A, S}: Corner tensor

• E::TensorKit.AbstractTensorMap{A, S, 2, 1} where {A, S}: Edge tensor

mutable struct c6vCTM_triangular{A, S}

C6v symmetric Corner Transfer Matrix Renormalization Group

Constructors

c6vCTM_triangular(T)
c6vCTM_triangular(T, [, symmetrize=false])

     (120°)     (60°)
        ╲       ╱
         ╲     ╱
          ╲   ╱
(180°)----- T -----(0°)
           ╱ ╲
          ╱   ╲
         ╱     ╲
      (240°) (300°)

c6vCTM can be called with a (3, 3) tensor, where the directions are (180°, 240°, 300°, 120°, 60°, 0°) clockwise with respect to the positive x-axis. In the flipped arrow convention, the arrows point from (120°, 60°, 0°) to (180°, 240°, 300°). or with a (0,6) tensor (120°, 60°, 0°, 300°, 240°, 180°) where all arrows point inward (unflipped arrow convention). The keyword argument symmetrize makes the tensor C6v symmetric when set to true. If symmetrize = false, it checks the symmetry explicitly.

Running the algorithm

run!(::c6vCTM, trunc::MatrixAlgebraKit.TruncationStrategy, stop::Stopcrit[, finalize_beginning=true, projectors=:twothirds, conditioning=true, verbosity=1])

projectors can either be :twothirds or :full, determining the type of projectors used in the renormalization step. This is based on https://arxiv.org/abs/2510.04907v1. conditioning determines whether to condition the second projector construction. This is based on https://doi.org/10.1103/PhysRevB.98.235148.

Fields

• T::TensorKit.TensorMap{A, S, 0, 6, A1} where {A, S, A1<:DenseVector{A}}

• C::TensorKit.TensorMap{A, S, 2, 1, A1} where {A, S, A1<:DenseVector{A}}

• Ea::TensorKit.TensorMap{A, S, 2, 1, A1} where {A, S, A1<:DenseVector{A}}

• Eb::TensorKit.TensorMap{A, S, 2, 1, A1} where {A, S, A1<:DenseVector{A}}

References

• Naumann et al. Phys. Rev. B 113(4) (2026)
• c6v implementation provided by Sander De Meyer

mutable struct ctm_HOTRG{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}, TC<:TensorKit.AbstractTensorMap{E, S, 1, 1}, TE<:TensorKit.AbstractTensorMap{E, S, 2, 1}} <: TNRScheme{E, S}

Corner Transfer Matrix environment + Higher-Order Tensor Renormalization Group

Constructors

ctm_HOTRG(T, χenv[, ctm_iter=maxiter(2.0e4), ctm_tol=trivial_convcrit(1.0e-9), ctm_obc=false, χenv_ini=2])

Running the algorithm

run!(::ctm_HOTRG, trunc::TruncationStrategy, criterion::stopcrit[, sweep=30, inv=false, conv_criterion=1.0e-12])

Fields

• T::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}

• C2::TensorKit.AbstractTensorMap{E, S, 1, 1} where {E, S}

• E1::TensorKit.AbstractTensorMap{E, S, 2, 1} where {E, S}

• E2::TensorKit.AbstractTensorMap{E, S, 2, 1} where {E, S}

• χenv::Int64

References

• Morita & Kawashima Phys. Rev. B 103(4) (2021)

mutable struct ctm_TRG{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}, TC<:TensorKit.AbstractTensorMap{E, S, 1, 1}, TE<:TensorKit.AbstractTensorMap{E, S, 2, 1}} <: TNRScheme{E, S}

Corner Transfer Matrix environment + Tensor Renormalization Group

Constructors

ctm_TRG(T, χenv[, ctm_iter=2.0e4, ctm_tol=1.0e-9])

Running the algorithm

run!(::ctm_TRG, trunc::TruncationStrategy, criterion::maxiter[, sweep=30, enlarge=true, inv=false, conv_criterion=1.0e-12, modified=true])

Fields

• T::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}

• C2::TensorKit.AbstractTensorMap{E, S, 1, 1} where {E, S}

• E1::TensorKit.AbstractTensorMap{E, S, 2, 1} where {E, S}

• E2::TensorKit.AbstractTensorMap{E, S, 2, 1} where {E, S}

• χenv::Int64

References

• Morita & Kawashima Phys. Rev. B 103(4) (2021)

mutable struct rCTM{E, S, TT<:TensorKit.AbstractTensorMap{E, S, 2, 2}, TC<:TensorKit.AbstractTensorMap{E, S, 1, 1}, TE<:TensorKit.AbstractTensorMap{E, S, 2, 1}} <: TNRScheme{E, S}

Reflection-symmetric Corner Transfer Matrix

Constructors

rCTM(T)

CTM with spatial reflection symmetry along x and y axis. This allows different edge tensors for the vertical and horizontal edges. The corner tensors are related by their mirror images.

Running the algorithm

run!(::rCTM, trunc::TruncationStrategy, criterion::TNRKit.stopcrit[, verbosity=1])

Fields

• T::TensorKit.AbstractTensorMap{E, S, 2, 2} where {E, S}

• C2::TensorKit.AbstractTensorMap{E, S, 1, 1} where {E, S}

• E1::TensorKit.AbstractTensorMap{E, S, 2, 1} where {E, S}

• E2::TensorKit.AbstractTensorMap{E, S, 2, 1} where {E, S}

ZN_gauge_theory_dual(N::Int, β::Real; T::Type{<:Number} = ComplexF64)

Constructs the dual tensor for the three-dimensional pure $\mathbb{Z}_N$ gauge theory at inverse coupling β. The resulting tensor is represented in the Fourier basis on $\mathbb{Z}_N$ and can be viewed as the dual clock-model formulation used for finite-temperature tensor-network studies.

References

• Naravane et al. arXiv:2602.13124 (2026)

apply!(top::TNO, bottom::TNO, trunc::TruncationStrategy)

Compose two TNO layers sitewise. The physical input leg of top is contracted with the physical output leg of bottom, after which each pair of corresponding virtual bonds is merged into a single fused bond.

The result is returned as a new TNO with the same unit-cell shape.

The "canonical" normalization constant for loop-TNR tensors, which is the eigenvalue with largest real part of the 2 x 2 transfer matrix.

classical_XY(charge_trunc::Int; kwargs...)
classical_XY(beta::Float64, charge_trunc::Int; kwargs...)
classical_XY(::Type{U1Irrep}, beta::Float64, charge_trunc::Int; T::Type{<:Number} = Float64)
classical_XY(::Type{CU1Irrep}, beta::Float64, charge_trunc::Int; T::Type{<:Number} = Float64)

Constructs the partition function tensor for a symmetric 2D square lattice for the classical XY model using inverse temperature beta and charge truncation charge_trunc. Compatible with U(1) symmetry or CU(1) = O(2) symmetry on each of its spaces. Defaults to CU(1) symmetry if the symmetry type is not provided.

Examples

    classical_XY(U1Irrep, 0.9, 6)
    classical_XY(CU1Irrep, 0.9, 4)

References

• Yu et. al. 10.1103/PhysRevE.89.013308 (2014)

classical_clock(q::Int, β::Real; kwargs...)
classical_clock(::Type{Trivial}, q::Int, β::Real; T::Type{<:Number} = Float64)
classical_clock(::Type{ZNIrrep{N}}, q::Int, β::Real; T::Type{<:Number} = Float64) where {N}
classical_clock(::Type{DNIrrep{N}}, q::Int, β::Real; T::Type{<:Number} = Float64) where {N}

Constructs the partition function tensor for the classical clock model with q states and a given inverse temperature β.

Compatible with no symmetry, with explicit ℤq symmetry or Dq symmetry on each of its spaces. Defaults to Dq symmetry if the symmetry type is not provided.

classical_ising(; kwargs...)
classical_ising(β::Real; kwargs...)
classical_ising(::Type{Trivial}, β::Real; T::Type{<:Number} = Float64, h = 0.0)
classical_ising(::Type{Z2Irrep}, β::Real; T::Type{<:Number} = Float64, h = 0.0)

Constructs the partition function tensor for a 2D square lattice for the classical Ising model with a given inverse temperature β and external magnetic field h. Compatible with no symmetry for h ≠ 0 or with explicit ℤ₂ symmetry for h = 0 on each of its spaces. Defaults to ℤ₂ symmetry and h = 0 if the symmetry type and magnetic field are not provided.

Examples

    classical_ising() # Default symmetry is `Z2Irrep`, default inverse temperature is `ising_βc` and default magnetic field `h = 0`.
    classical_ising(Trivial, 0.5; h = 1.0) # Custom inverse temperature without symmetry and custom magnetic field `h`.

!!! info
    When studying this model with impurities, the tensor without symmetry should be constructed, as the impurity breaks the ℤ₂ symmetry.

See also: classical_ising_3D.

classical_ising_3D(; kwargs...)
classical_ising_3D(β::Real; kwargs...)
classical_ising_3D(::Type{Trivial}, β::Real; T::Type{<:Number} = Float64, J = 1.0)
classical_ising_3D(::Type{Z2Irrep}, β::Real; T::Type{<:Number} = Float64, J = 1.0)

Constructs the partition function tensor for a symmetric 3D cubic lattice for the classical Ising model with a given inverse temperature β.

Compatible with no symmetry or with explicit ℤ₂ symmetry on each of its spaces. Defaults to ℤ₂ symmetry and coupling constant J = 1.0 if the symmetry type and coupling constant are not provided.

Examples

    classical_ising_3D() # Default ℤ₂ symmetry, inverse temperature is `ising_βc_3D`, coupling constant is `J = 1.0`.
    classical_ising_3D(Trivial, 0.5; J = 1.5) # Custom inverse temperature and coupling constant.
    classical_ising_3D(Z2Irrep, 0.5; J = 1.5) # Custom inverse temperature and coupling constant with ℤ₂ symmetry.

See also: classical_ising.

classical_ising_honeycomb(; kwargs...)
classical_ising_honeycomb(β::Real; kwargs...)
classical_ising_honeycomb(::Type{Trivial}, β::Real; T::Type{<:Number} = Float64)
classical_ising_honeycomb(::Type{Z2Irrep}, β::Real; T::Type{<:Number} = Float64)

Constructs the partition function tensor for a 2D honeycomb lattice for the classical Ising model with a given inverse temperature β. Compatible with no symmetry or with explicit ℤ₂ symmetry on each of its spaces. Defaults to ℤ₂ symmetry and inverse temperature ising_βc_honeycomb if the symmetry type and inverse temperature are not provided.

Examples

    classical_ising_honeycomb() # Default ℤ₂ symmetry, inverse temperature is `ising_βc_honeycomb`
    classical_ising_honeycomb(Trivial, 0.5) # Custom inverse temperature.
    classical_ising_honeycomb(Z2Irrep, 0.5) # Custom inverse temperature with explicit ℤ₂ symmetry.

classical_ising_impurity([Type{Trivial}], β::Real; T::Type{<:Number} = Float64, h = 0.0)

Constructs the partition function tensor for a 2D square lattice for the classical Ising model with a given inverse temperature β and external magnetic field h with a magnetisation impurity. Compatible with no symmetry on each of its spaces.

Examples

    classical_ising_impurity() # Default inverse temperature is `ising_βc`
    classical_ising_impurity(0.5; h = 1.0) # Custom inverse temperature and magnetic field

See also: classical_ising, classical_ising_3D.

classical_ising_triangular(; kwargs...)
classical_ising_triangular(β::Real; kwargs...)
classical_ising_triangular(::Type{Trivial}, β::Real; T::Type{<:Number} = Float64)
classical_ising_triangular(::Type{Z2Irrep}, β::Real; T::Type{<:Number} = Float64)

Constructs the partition function tensor for a 2D triangular lattice for the classical Ising model with a given inverse temperature β. Compatible with no symmetry or with explicit ℤ₂ symmetry on each of its spaces. Defaults to ℤ₂ symmetry and inverse temperature ising_βc_triangular if the symmetry type and inverse temperature are not provided.

Examples

    classical_ising_triangular() # Default ℤ₂ symmetry, inverse temperature is `ising_βc_triangular`
    classical_ising_triangular(Trivial, 0.5) # Custom inverse temperature wihout symmetry.
    classical_ising_triangular(0.5) # Custom inverse temperature with ℤ₂ symmetry.

classical_potts(q::Int, β::Real; kwargs...)
classical_potts(::Type{Trivial}, q::Int, β::Float64; kwargs...)
classical_potts(::Type{ZNIrrep{N}}, q::Int, β::Float64; kwargs...) where {N}

Constructs the partition function tensor for the classical Potts model with q states and a given inverse temperature β.

Compatible with no symmetry or with explicit ℤq symmetry on each of its spaces. Defaults to ℤq symmetry if the symmetry type is not provided.

Examples

    classical_potts(3) # Default has Z₃ symmetry and uses `potts_βc(3)` as the inverse temperature.
    classical_potts(Z3Irrep, 3, 0.5) # Custom inverse temperature with explicit ℤ₃ symmetry.

See also: potts_βc.

classical_potts_impurity(q::Int64, β::Real, k1::Int64 = 1, k2::Int64 = 1; T::Type{<:Number} = Float64)
classical_potts_impurity(q::Int64, k1::Int64, k2::Int64; T::Type{<:Number} = Float64)
classical_potts_impurity(q::Int64; T::Type{<:Number} = Float64)

Constructs the partition function tensor for a Potts model with q states and a given inverse temperature β with impurities in sectors k1 and k2.

The impurity breaks the ℤq symmetry, but the impurity sectors match the symmetry sectors of the model.

Examples

    classical_potts_impurity(3) # Default inverse temperature is `potts_βc(3)`
    classical_potts_impurity(3, 1, 2) # Custom inverse temperature and impurity sectors.
    classical_potts_impurity(3, 0.5, 2, 3) # Custom inverse temperature and impurity sectors.

See also: classical_potts, potts_βc.

free_energy(data, β; scalefactor, initial_size)

Takes a vector of normalization factors data and a given inverse temperature β and computes the free energy.

gross_neveu_start([::Type{FermionParity}], μ::Number, m::Number, g::Number; T::Type{<:Complex} = ComplexF64)

Constructs the partition function tensor for the Gross-Neveu model with given parameters μ, m, and g. Compatible with explicit fermion parity symmetry on each of its spaces.

References

• Akiyama et. al. J. Phys.: Condens. Matter 36 (2024) 343002

ground_state_degeneracy(scheme)
ground_state_degeneracy(scheme, unitcell)

Calculates the Ground State Degeneracy (GSD) from the fixed-point tensor of a TNRScheme, using the eigenvalues of the transfer matrix. The GSD is the exponential of the Shannon entropy.

gu_wen_ratio(scheme)

Calculates the Gu-Wen ratio X1 and X2 from the fixed-point tensor of a TNRScheme. The Gu-Wen ratios are related to the Ground state Degeneracy and the the scaling dimensions. See references.

References

• Zheng-Cheng Gu & Xiao-Gang Wen. PhysRevB.80.155131
• Satoshi Morita et al. arxiv:2512.03395

ising_3D_free_energy_htse(β::Real; J::Real=1.0, max_order::Int=24)

Compute the free energy per spin for the 3D Ising model on a simple cubic lattice using the high-temperature series expansion (HTSE) to 24th order.

The expansion is taken from Bhanot, Creutz, Glässner, Schilling (hep-lat/9312048), Table 2, with the formula:

f(β) = -(1/β) * log(2*cosh(β*J)³) - (1/β) * Σ_{k} f_k * tanh(β*J)^k

Arguments

• β: Inverse temperature.
• J: Coupling constant (default: 1.0).
• max_order: Maximum order of the series expansion (default: 24, max: 24).

Examples

julia> ising_3D_free_energy_htse(ising_βc_3D)
-3.5083582548883747

References

• Bhanot et. al. Phys. Rev. B 49 (1994)

Given a LoopTNR scheme, consider the loop MPS |ψ⟩ = tr(TA * TB * TA * TB). Compute a gauge-invariant data called loop entropy on each of the four edges of the loop MPS. This loop entropy is defined as the von Neumann entropy of the transfer matrix formed by contracting the loop MPS with itself, with the bond of interest as the cut. The loop entropy is a measure of the entanglement across the bond, and can be used to diagnose the presence of short-range entanglement in the loop MPS. The entanglement spectrum is also returned.

References

• Evenbly et. al. Phys. Rev. B 98 (2018)

phi4_complex(K::Integer, μ0::Float64, λ::Float64; kwargs...)
phi4_complex(::Type{Trivial}, K::Integer, μ0::Float64, λ::Float64; T::Type{<:Number} = Float64)
phi4_complex(::Type{Z2Irrep ⊠ Z2Irrep}, K::Integer, μ0::Float64, λ::Float64; T::Type{<:Number} = Float64)
phi4_complex(::Type{U1Irrep}, K::Integer, μ0::Float64, λ::Float64; T::Type{<:Number} = Float64)

Constructs the partition function tensor for a 2D square lattice for the complex ϕ^4 model with a given approximation K, bare mass µ_0^2 μ0 and interaction constant λ.

It is based on Gauss-Hermite quadrature.

Compatible with no symmetry, explicit ℤ₂×ℤ₂ symmetry or explicit U(1) symmetry on each of its spaces. Defaults to U(1) symmetry if the symmetry type is not provided.

Arguments

• K::Integer: Approximation parameter.
• μ0::Float64: Bare mass. Note that in the calculation actually $µ_0^2$ is used, but for readibility we write the $µ_0^2$ as μ0
• λ::Float64: Coupling constant.

Approximation parameter K

Trivial (no symmetry)

The tensor is constructed by performing a Gauss-Hermite quadrature to approximate the integrals in the partition function. The bond dimension is equal to K^2.

ℤ₂×ℤ₂ symmetry

The tensor is constructed by Taylor expanding the mixed sites term in the partition function. The order of the Taylor expansion is K. The total bond dimension is K^2.

U(1) symmetry

The tensor is constructed by Taylor expanding the mixed sites term in the partition function. The order of the Taylor expansion is K. The total bond dimension is K^2.

Examples

    phi4_complex(10, -1., 1.)

References

Piceu Jarid and Adwait Naravane, but based on:

• Kadoh et. al. 10.1007/JHEP05(2019)184 (2019)
• Delcamp et. al. Phys. Rev. Research 2, 033278 (2020)

See also: phi4_complex_impϕ, phi4_complex_impϕdag, phi4_complex_impϕabs, phi4_complex_impϕ2, phi4_complex_all.

phi4_complex_all([Type{Trivial}], K::Integer, μ0::Float64, λ::Float64; T::Type{<:Number} = ComplexF64)

Constructs all the tensors: the partition function tensor and all the impurity tensors for a 2D square lattice for the complex ϕ^4 model with a given approximation K, bare mass µ_0^2 μ0 and interaction constant λ.

It is faster to compute them all at once than one for one individually.

It is based on Gauss-Hermite quadrature.

Arguments

• K::Integer: Number of quadrature points for Gauss-Hermite integration.
• μ0::Float64: Bare mass. Note that in the calculation actually $µ_0^2$ is used, but for readibility we write the $µ_0^2$ as μ0
• λ::Float64: Coupling constant.

Examples

    phi4_complex_all(10, -1., 1.)

References

Piceu Jarid, but based on Kadoh et. al. 10.1007/JHEP05(2019)184 (2019)

See also: phi4_complex, phi4_complex_impϕ, phi4_complex_impϕdag, phi4_complex_impϕabs, phi4_complex_impϕ2.

phi4_complex_impϕ([Type{Trivial}], K::Integer, μ0::Float64, λ::Float64; T::Type{<:Number} = ComplexF64)

Constructs the impurity tensor for a 2D square lattice for the complex ϕ^4 model with a given approximation K, bare mass µ_0^2 μ0 and interaction constant λ.

The impurity is a ϕ operator on this site.

It is based on Gauss-Hermite quadrature.

Arguments

• K::Integer: Number of quadrature points for Gauss-Hermite integration.
• μ0::Float64: Bare mass. Note that in the calculation actually $µ_0^2$ is used, but for readibility we write the $µ_0^2$ as μ0
• λ::Float64: Coupling constant.

Examples

    phi4_complex_impϕ(10, -1., 1.)

References

Piceu Jarid, but based on Kadoh et. al. 10.1007/JHEP05(2019)184 (2019)

See also: phi4_complex, phi4_complex_impϕdag, phi4_complex_impϕabs, phi4_complex_impϕ2, phi4_complex_all.

phi4_complex_impϕ2([Type{Trivial}], K::Integer, μ0::Float64, λ::Float64; T::Type{<:Number} = ComplexF64)

Constructs the impurity tensor for a 2D square lattice for the complex ϕ^4 model with a given approximation K, bare mass µ_0^2 μ0 and interaction constant λ.

The impurity is a ϕϕ† operator on this site.

It is based on Gauss-Hermite quadrature.

Arguments

• K::Integer: Number of quadrature points for Gauss-Hermite integration.
• μ0::Float64: Bare mass. Note that in the calculation actually $µ_0^2$ is used, but for readibility we write the $µ_0^2$ as μ0
• λ::Float64: Coupling constant.

Examples

    phi4_complex_impϕ2(10, -1., 1.)

References

Piceu Jarid, but based on Kadoh et. al. 10.1007/JHEP05(2019)184 (2019)

See also: phi4_complex, phi4_complex_impϕ, phi4_complex_impϕdag, phi4_complex_impϕabs, phi4_complex_all.

phi4_complex_impϕabs([Type{Trivial}], K::Integer, μ0::Float64, λ::Float64; T::Type{<:Number} = ComplexF64)

Constructs the impurity tensor for a 2D square lattice for the complex ϕ^4 model with a given approximation K, bare mass µ_0^2 μ0 and interaction constant λ.

The impurity is a √(ϕϕ†) operator on this site.

It is based on Gauss-Hermite quadrature.

Arguments

• K::Integer: Number of quadrature points for Gauss-Hermite integration.
• μ0::Float64: Bare mass. Note that in the calculation actually $µ_0^2$ is used, but for readibility we write the $µ_0^2$ as μ0
• λ::Float64: Coupling constant.

Examples

    phi4_complex_impϕabs(10, -1., 1.)

References

Piceu Jarid, but based on Kadoh et. al. 10.1007/JHEP05(2019)184 (2019)

See also: phi4_complex, phi4_complex_impϕ, phi4_complex_impϕdag, phi4_complex_impϕ2, phi4_complex_all.

phi4_complex_impϕdag([Type{Trivial}], K::Integer, μ0::Float64, λ::Float64; T::Type{<:Number} = ComplexF64)

Constructs the impurity tensor for a 2D square lattice for the complex ϕ^4 model with a given approximation K, bare mass µ_0^2 μ0 and interaction constant λ.

The impurity is a ϕ† operator on this site.

It is based on Gauss-Hermite quadrature.

Arguments

• K::Integer: Number of quadrature points for Gauss-Hermite integration.
• μ0::Float64: Bare mass. Note that in the calculation actually $µ_0^2$ is used, but for readibility we write the $µ_0^2$ as μ0
• λ::Float64: Coupling constant.

Examples

    phi4_complex_impϕdag(10, -1., 1.)

References

Piceu Jarid, but based on Kadoh et. al. 10.1007/JHEP05(2019)184 (2019)

See also: phi4_complex, phi4_complex_impϕ, phi4_complex_impϕabs, phi4_complex_impϕ2, phi4_complex_all.

phi4_real(K::Integer, μ0::Float64, λ::Float64, h::Float64 = 0.0; kwargs...)
phi4_real(::Type{Trivial}, K::Integer, μ0::Float64, λ::Float64, h::Float64 = 0.0; T::Type{<:Number} = Float64)
phi4_real(::Type{Z2Irrep}, K::Integer, μ0::Float64, λ::Float64; T::Type{<:Number} = Float64)

Constructs the partition function tensor for a 2D square lattice for the real ϕ^4 model with a given approximation (and bond dimension) K, bare mass $µ_0^2$ μ0, interaction constant λ and external field h.

Compatible with no symmetry or with explicit ℤ₂ symmetry on each of its spaces. Defaults to ℤ₂ symmetry and h = 0 if the symmetry type and magnetic field are not provided.

Arguments

• K::Integer: Approximation parameter.
• μ0::Float64: Bare mass. Note that in the calculation actually $µ_0^2$ is used, but for readibility we write the $µ_0^2$ as μ0
• λ::Float64: Coupling constant.
• h::Float64: External field (default is 0).

Approximation parameter K

Trivial (no symmetry)

The tensor is constructed by performing a Gauss-Hermite quadrature to approximate the integrals in the partition function. The bond dimension is equal to the number of quadrature points K.

ℤ₂ symmetry

The tensor is constructed by Taylor expanding the mixed sites term in the partition function. The order of the Taylor expansion is K, and the bond dimension is K/2 for the even and odd sectors each (K in total). Not compatible with a non-zero magnetic field, as the magnetic field breaks the ℤ₂ symmetry.

Examples

    phi4_real(10, -1.0, 1.0, 1.0) # default ℤ₂ symmetry, h = 0
    phi4_real(Trivial, 10, -1.0, 1.0, 1.0) # no symmetry with magnetic field

References

• Kadoh et. al. 10.1007/JHEP05(2019)184 (2019)
• Delcamp et. al. Phys. Rev. Research 2, 033278 (2020)

See also: phi4_real_imp1, phi4_real_imp2.

phi4_real_imp1([Type{Trivial}], K::Integer, μ0::Float64, λ::Float64, h::Float64 = 0.0; T::Type{<:Number} = Float64)

Constructs the impurity tensor for a 2D square lattice for the real ϕ^4 model with a given approximation (and bond dimension) K, bare mass $µ_0^2$ μ0, interaction constant λ and external field h.

The impurity is a ϕ operator on this site.

It is based on Gauss-Hermite quadrature.

Arguments

• K::Integer: Number of quadrature points for Gauss-Hermite integration.
• μ0::Float64: Bare mass. Note that in the calculation actually $µ_0^2$ is used, but for readibility we write the $µ_0^2$ as μ0
• λ::Float64: Coupling constant.
• h::Float64: External field (default is 0).

Examples

    phi4_real_imp1(10, -1.0, 1.0, 0.0)

References

• Kadoh et. al. 10.1007/JHEP05(2019)184 (2019)

See also: phi4_real, phi4_real_imp2.

phi4_real_imp2([Type{Trivial}], K::Integer, μ0::Float64, λ::Float64, h::Float64 = 0.0; T::Type{<:Number} = Float64)

Constructs the impurity tensor for a 2D square lattice for the real ϕ^4 model with a given approximation (and bond dimension) K, bare mass $µ_0^2$ μ0, interaction constant λ and external field h.

The impurity is a ϕ^2 operator on this site.

It is based on Gauss-Hermite quadrature.

Arguments

• K::Integer: Number of quadrature points for Gauss-Hermite integration.
• μ0::Float64: Bare mass. Note that in the calculation actually $µ_0^2$ is used, but for readibility we write the $µ_0^2$ as μ0
• λ::Float64: Coupling constant.
• h::Float64: External field (default is 0).

Examples

    phi4_real_imp2(10, -1.0, 1.0, 0.0)

References

• Kadoh et. al. 10.1007/JHEP05(2019)184 (2019)

See also: phi4_real, phi4_real_imp1.

potts_βc(q)

returns the inverse critical temperature for the classical q-state Potts model on a 2D square lattice.

See also: classical_potts.

Given a tensormap T, the function computes its singular value decomposition (SVD) and applies soft-thresholding to the singular values σ ↦ max(σ - τ, 0). The resulting tensor is reconstructed using the thresholded singular values, and the function also returns the reduced rank (number of non-zero singular values after thresholding) and the nuclear norm (sum of the thresholded singular values).

sixvertex(; kwargs...)
sixvertex(::Type{Trivial}; T::Type{<:Number} = Float64, a = 1.0, b = 1.0, c = 1.0)
sixvertex(::Type{U1Irrep}; T::Type{<:Number} = Float64, a = 1.0, b = 1.0, c = 1.0)
sixvertex(::Type{CU1Irrep}; T::Type{<:Number} = Float64, a = 1.0, b = 1.0, c = 1.0)

Constructs the partition function tensor for the six-vertex model with a given symmetry type and coupling constants a, b, and c. Compatible with no symmetry, U(1) symmetry, or CU(1) symmetry on each of its spaces.

Defaults

- T: Float64
- symmetry: CU1Irrep
- a: 1.0
- b: 1.0
- c: 1.0

Examples

    sixvertex() # Default symmetry is `CU1Irrep`, coupling constants are `a = 1.0`, `b = 1.0`, `c = 1.0`.
    sixvertex(Trivial) # No symmetry with default coupling constants.
    sixvertex(ComplexF64, U1Irrep; a = 2.0, b = 3.0, c = 4.0) # U1 symmetry with custom coupling constants and element type.

Note: The free energy density depends on the boundary conditions.

step!(scheme::CorrelationHOTRG, trunc::TensorKit.TruncationStrategy)

Perform a single iteration step of the Correlation HOTRG algorithm.

This function progresses through three phases:

• Phase 1: Evolve the pure tensor with two separate impurity tensors.
• Phase 2: Merge the two impurity tensors into a single impurity tensor.
• Phase 3: Continue evolution with the single merged impurity tensor.

The algorithm determines which phase to execute based on the current iteration count. After each phase, tensors are finalized and the iteration counter is incremented.

Arguments

• scheme::CorrelationHOTRG: The HOTRG scheme containing the tensors and state.
• trunc::TensorKit.TruncationStrategy: The truncation scheme to apply during tensor operations.

Returns

• scheme::CorrelationHOTRG: The updated scheme with evolved tensors and incremented iteration count.

Perform SVD of t in the "reversed" direction such that t = u * s * vh and the arrow direction is u → s → vh.

Twist the i-th leg of a tensor t if it represents a dual space.

Twist the i-th leg of a tensor t if it represents a non-dual space.

weyl_heisenberg_matrices(dimension [, eltype])

the Weyl-Heisenberg matrices according to Wikipedia.

Coarse-grain ΨB to renormalized TA, TB tensors