Documentation

function quanticscrossinterpolate(
    ::Type{ValueType},
    f,
    size::NTuple{d,Int},
    initialpivots::AbstractVector{<:AbstractVector}=[ones(Int, d)];
    unfoldingscheme::Symbol=:interleaved,
    kwargs...
) where {ValueType,d}

Interpolate a Tensor $F$ as a quantics tensor train. For an explanation of arguments, etc., see the documentation of the main overload.

function quanticscrossinterpolate(
    ::Type{ValueType},
    f,
    xvals::AbstractVector{<:AbstractVector},
    initialpivots::Union{Nothing,AbstractVector{<:AbstractVector}}=nothing;
    unfoldingscheme::Symbol=:interleaved,
    nrandominitpivot=5,
    kwargs...
) where {ValueType}

Interpolate a function $f(\mathbf{x})$ as a quantics tensor train. This overload automatically constructs a Grid object from the $\mathbf{x}$ points given in xvals.

Arguments:

• xvals::AbstractVector{<:AbstractVector}: A set of discrete points where f can be evaluated, given as a set of arrays, where xvals[i] describes the ith axis. Each array in xvals should contain 2^R points for some integer R.
• For all other arguments, see the documentation of the main overload.

function quanticscrossinterpolate(
    ::Type{ValueType},
    f,
    xvals::AbstractVector,
    initialpivots::AbstractVector=[1];
    kwargs...
) where {ValueType}

Interpolate a function $f(x)$ as a quantics tensor train. This is an overload for 1d functions. For an explanation of arguments and return type, see the documentation of the main overload.

function quanticscrossinterpolate(
    ::Type{ValueType},
    f,
    size::NTuple{d,Int},
    initialpivots::AbstractVector{<:AbstractVector}=[ones(Int, d)];
    unfoldingscheme::Symbol=:interleaved,
    kwargs...
) where {ValueType,d}

Interpolate a function $f(\mathbf{x})$ as a quantics tensor train. This overload automatically constructs a Grid object using the information contained in size. Here, the ith argument runs from 1 to size[i].

function quanticscrossinterpolate(
    ::Type{ValueType},
    f,
    grid::QuanticsGrids.Grid{n},
    initialpivots::Union{Nothing,AbstractVector{<:AbstractVector}}=nothing;
    nrandominitpivot=5,
    kwargs...
) where {ValueType}

Interpolate a function $f(\mathbf{x})$ as a quantics tensor train. The tensor train itself is constructed using the 2-site tensor cross interpolation algorithm implemented in TensorCrossInterpolation.crossinterpolate2.

Arguments:

• ValueType is the return type of f. Automatic inference is too error-prone.
• f is the function to be interpolated. f may take multiple arguments. The return type should be ValueType.
• grid is a Grid{n} object from QuanticsGrids.jl that describes a d-dimensional grid of discrete points indexed by binary digits. To avoid constructing a grid explicitly, use one of the other overloads.
• initialpivots is a vector of pivots to be used for initialization.
• nrandominitpivot determines how many random pivots should be used for initialization if no initial pivot is given.

All other arguments are forwareded to crossinterpolate2. Most importantly:

• tolerance::Float64 is a float specifying the target tolerance for the interpolation. Default: 1e-8.
• pivottolerance::Float64 is a float that specifies the tolerance for adding new pivots, i.e. the truncation of tensor train bonds. It should be <= tolerance, otherwise convergence may be impossible. Default: tolerance.
• maxbonddim::Int specifies the maximum bond dimension for the TCI. Default: typemax(Int), i.e. effectively unlimited.
• maxiter::Int is the maximum number of iterations (i.e. optimization sweeps) before aborting the TCI construction. Default: 200.

For all other arguments, see the documentation for TensorCrossInterpolation.crossinterpolate2.

function quanticsfouriermpo(
    R::Int;
    sign::Float64=-1.0,
    maxbonddim::Int=12,
    tolerance::Float64=1e-14,
    K::Int=25,
    method::Symbol=:SVD,
    normalize::Bool=true
)::TCI.TensorTrain{ComplexF64}

Generate a quantics Fourier transform operator in tensor train form. When contracted with a quantics tensor train $F_{\boldsymbol{\sigma}}$ representing a function, the result will be the fourier transform of the function in quantics tensor train form, $\tilde{F}_{\boldsymbol{\sigma}'} = \sum_{\boldsymbol{\sigma}} F_{\boldsymbol{\sigma}} \exp(-2\pi i (k_{\boldsymbol{\sigma'}}-1) (m_{\boldsymbol{\sigma}} - 1)/M)$, where $k_{\boldsymbol{\sigma}} = \sum_{\ell=1}^R 2^{R-\ell} \sigma_\ell$, $m_{\boldsymbol{\sigma}'} = \sum_{\ell=1}^R 2^{R-\ell} \sigma'_\ell$, and $M=2^R$.

The Fourier transform operator is implemented using a direct analytic construction of the tensor train by Chen and Lindsey (see reference 2). The tensor train thus obtained is then re-compressed to the user-given bond dimension and tolerance.

Arguments:

• R: number of bits of the fourier transform.
• sign: sign in the exponent $\exp(2i\pi \times \mathrm{sign} \times (k_{\boldsymbol{\sigma'}}-1) (x_{\boldsymbol{\sigma}}-1)/M)$, usually $\pm 1$.
• maxbonddim: bond dimension to compress the operator to. From observations, maxbonddim = 12 is generally big enough to reach an accuracy of 1e-12.
• tolerance: tolerance of the TT compression. Note that the error in the fourier transform is generally a bit larger than this error tolerance.
• K: bond dimension of the TT before compression, i.e. number of basis functions to approximate the Fourier transform with (see reference 2). The TT will become inaccurate for K < 22; higher values may be necessary for very high precision.
• method: method with which to compress the TT. Choose between :SVD and :CI.
• normalize: whether or not to normalize the operator as an isometry.