Public API

Index

• NeuralQuantumStates.Hilberts.CompositeSumConstraint
• NeuralQuantumStates.Hilberts.CompositeUniformHilbert
• NeuralQuantumStates.Hilberts.FiniteUniformHilbert
• NeuralQuantumStates.Hilberts.InfiniteUniformHilbert
• NeuralQuantumStates.Hilberts.NoCompositeDiscreteHilbertConstraint
• NeuralQuantumStates.Hilberts.NoDiscreteHilbertConstraint
• NeuralQuantumStates.Hilberts.SumConstraint
• NeuralQuantumStates.Lattices.Lattice
• NeuralQuantumStates.Lattices.Lattice
• NeuralQuantumStates.Lattices.Lattice
• NeuralQuantumStates.Lattices.Lattice
• NeuralQuantumStates.Lattices.Lattice
• NeuralQuantumStates.Lattices.LatticeBasis
• NeuralQuantumStates.Lattices.LatticeBasis
• NeuralQuantumStates.Lattices.LatticeBasis
• NeuralQuantumStates.Lattices.LatticeBasis
• NeuralQuantumStates.Lattices.LatticeBasis
• NeuralQuantumStates.Lattices.LatticeBasis
• NeuralQuantumStates.Operators.BoseHubbardOperator
• NeuralQuantumStates.Operators.TransverseFieldIsingOperator
• NeuralQuantumStates.Hilberts.:⊗
• NeuralQuantumStates.Hilberts.all_states
• NeuralQuantumStates.Hilberts.all_states
• NeuralQuantumStates.Hilberts.all_states
• NeuralQuantumStates.Hilberts.build
• NeuralQuantumStates.Hilberts.build
• NeuralQuantumStates.Hilberts.build
• NeuralQuantumStates.Hilberts.check
• NeuralQuantumStates.Hilberts.check
• NeuralQuantumStates.Hilberts.check
• NeuralQuantumStates.Hilberts.check
• NeuralQuantumStates.Hilberts.n_DoF
• NeuralQuantumStates.Hilberts.n_lDoF
• NeuralQuantumStates.Hilberts.n_lDoF
• NeuralQuantumStates.Hilberts.n_lDoF
• NeuralQuantumStates.Hilberts.n_states
• NeuralQuantumStates.Hilberts.n_states
• NeuralQuantumStates.Hilberts.state_index_to_state
• NeuralQuantumStates.Hilberts.state_index_to_state
• NeuralQuantumStates.Hilberts.state_to_state_index
• NeuralQuantumStates.Hilberts.state_to_state_index
• NeuralQuantumStates.Lattices.build
• NeuralQuantumStates.Lattices.build
• NeuralQuantumStates.Lattices.build
• NeuralQuantumStates.Lattices.build
• NeuralQuantumStates.Lattices.build
• NeuralQuantumStates.Operators.build
• NeuralQuantumStates.Operators.build
• NeuralQuantumStates.Operators.connected_basis_configs
• NeuralQuantumStates.Operators.connected_basis_configs
• NeuralQuantumStates.Operators.connected_basis_configs
• NeuralQuantumStates.Operators.connected_basis_configs
• NeuralQuantumStates.Operators.connected_basis_configs
• NeuralQuantumStates.Operators.connected_basis_configs

NeuralQuantumStates.Lattices.Lattice Type

Lattice{Tᵢ<:Integer,T<:Real,D,O}
    <: NeuralQuantumStates.Lattices.AbstractLattice{Tᵢ,T,D,O}

A D-dimensional NeuralQuantumStates.Lattices.Lattice of shape with given lattice basis and periodic boundary conditions.

Fields

• metagraph::MetaGraph{Tᵢ}: A MetaGraphsNext.MetaGraph for the lattice to store its vertices and edges.

• shape::SVector{D,Tᵢ}: A vector for the shape of the lattice. It must contain D positive integers.

• basis::NeuralQuantumStates.Lattices.AbstractLatticeBasis{T,D,O}: A lattice basis for representing the unit cell of the lattice.

• periodic::SVector{D,Bool}: A vector for the periodic boundary condition of the lattice in each dimension.

source

NeuralQuantumStates.Lattices.Lattice Method

Lattice(
    shape::AbstractVector{Tᵢ},
    basis::NeuralQuantumStates.Lattices.AbstractLatticeBasis{T,D,O},
    custom_edges::Tuple{AbstractVector{NTuple{2,L}},AbstractVector{Tᵢ}},
    periodic::SVector{Bool}=fill(false, D)
) where {Tᵢ<:Integer,T<:Real,D,O,L} -> NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,D,O}

Build a D-dimensional NeuralQuantumStates.Lattices.Lattice of shape by using the given lattice basis, periodic boundary conditions and custom_edges.

Arguments

• shape::AbstractVector{Tᵢ}: A vector for the shape of the lattice. It must contain D positive integers.

• basis::NeuralQuantumStates.Lattices.AbstractLatticeBasis{T,D,O}: A lattice basis for representing the unit cell of the lattice.

• custom_edges::Tuple{AbstractVector{NTuple{2,L}},AbstractVector{Tᵢ}}: A tuple of two vectors for the custom edges to be added to the lattice. The first vector contains the lattice site labels of the edges to be added in the form of NTuple{2,L} where L is the type of the lattice site labels. The second vector is of positive integers for distingushing the edges to be added. These two vectors must have the same length.

• periodic::AbstractVector{Bool}: A vector for the periodic boundary condition of the lattice in each dimension. Defaults to fill(false, D).

Returns

• NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,D,O}: The built D-dimensional NeuralQuantumStates.Lattices.Lattice of shape by using the given lattice basis, periodic boundary conditions and custom_edges.

source

NeuralQuantumStates.Lattices.Lattice Method

Lattice(
    shape::SVector{D,Tᵢ},
    basis::NeuralQuantumStates.Lattices.AbstractLatticeBasis{T,D,O},
    custom_edges::Tuple{AbstractVector{NTuple{2,L}},AbstractVector{Tᵢ}},
    periodic::SVector{D,Bool}=SVector{D,Bool}(fill(false, D))
) where {Tᵢ<:Integer,T<:Real,D,O,L} -> NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,D,O}

Build a D-dimensional NeuralQuantumStates.Lattices.Lattice of shape by using the given lattice basis, periodic boundary conditions and custom_edges.

Arguments

• shape::SVector{D,Tᵢ}: A vector for the shape of the lattice. It must contain D positive integers.

• basis::NeuralQuantumStates.Lattices.AbstractLatticeBasis{T,D,O}: A lattice basis for representing the unit cell of the lattice.

• custom_edges::Tuple{AbstractVector{NTuple{2,L}},AbstractVector{Tᵢ}}: A tuple of two vectors for the custom edges to be added to the lattice. The first vector contains the lattice site labels of the edges to be added in the form of NTuple{2,L} where L is the type of the lattice site labels. The second vector is of positive integers for distingushing the edges to be added. These two vectors must have the same length.

• periodic::SVector{D,Bool}: A vector for the periodic boundary condition of the lattice in each dimension. Defaults to SVector{D,Bool}(fill(false, D)).

Returns

• NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,D,O}: The built D-dimensional NeuralQuantumStates.Lattices.Lattice of shape by using the given lattice basis, periodic boundary conditions and custom_edges.

source

NeuralQuantumStates.Lattices.Lattice Method

Lattice(
    shape::AbstractVector{Tᵢ},
    basis::NeuralQuantumStates.Lattices.AbstractLatticeBasis{T,D,O},
    periodic::AbstractVector{Bool}=fill(false, D);
    max_order::Tᵢ=1,
    tol_digits::Tᵢ=12,
    dist_tol::T=1.0e-12
) where {Tᵢ<:Integer,T<:Real,D,O} -> NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,D,O}

Build a D-dimensional NeuralQuantumStates.Lattices.Lattice of shape by using the given lattice basis and periodic boundary conditions.

Arguments

• shape::AbstractVector{Tᵢ}: A vector for the shape of the lattice. It must contain D positive integers.

• basis::NeuralQuantumStates.Lattices.AbstractLatticeBasis{T,D,O}: A lattice basis for representing the unit cell of the lattice.

• periodic::AbstractVector{Bool}: A vector for the periodic boundary condition of the lattice in each dimension. Defaults to fill(false, D).

Keywords

• max_order::Tᵢ: An integer for the maximum order of the edges to be included in the lattice as max_order-nearest neighbors. Defaults to 1, which means only nearest neighbors are included. For example, if it is set to 2, then nearest and next-nearest neighbors are included.

• tol_digits::Tᵢ: An integer for the number of digits to round the calculated distances to. Defaults to 12.

• dist_tol::T: A positive number for the tolerance of the distance between two lattice sites to be considered as the same site. Defaults to 1.0e-12.

Returns

• NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,D,O}: The built D-dimensional NeuralQuantumStates.Lattices.Lattice of shape by using the given lattice basis and periodic boundary conditions.

source

NeuralQuantumStates.Lattices.Lattice Method

Lattice(
    shape::SVector{D,Tᵢ},
    basis::NeuralQuantumStates.Lattices.AbstractLatticeBasis{T,D,O},
    periodic::SVector{D,Bool}=SVector{D,Bool}(fill(false, D));
    max_order::Tᵢ=1,
    tol_digits::Tᵢ=12,
    dist_tol::T=1.0e-12
) where {Tᵢ<:Integer,T<:Real,D,O} -> NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,D,O}

Build a D-dimensional NeuralQuantumStates.Lattices.Lattice of shape by using the given lattice basis and periodic boundary conditions.

Arguments

• shape::SVector{D,Tᵢ}: A vector for the shape of the lattice. It must contain D positive integers.

• basis::NeuralQuantumStates.Lattices.AbstractLatticeBasis{T,D,O}: A lattice basis for representing the unit cell of the lattice.

• periodic::SVector{D,Bool}: A vector for the periodic boundary condition of the lattice in each dimension. Defaults to SVector{D,Bool}(fill(false, D)).

Keywords

• max_order::Tᵢ: An integer for the maximum order of the edges to be included in the lattice as max_order-nearest neighbors. Defaults to 1, which means only nearest neighbors are included. For example, if it is set to 2, then nearest and next-nearest neighbors are included.

• tol_digits::Tᵢ: An integer for the number of digits to round the calculated distances to. Defaults to 12.

• dist_tol::T: A positive number for the tolerance of the distance between two lattice sites to be considered as the same site. Defaults to 1.0e-12.

Returns

• NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,D,O}: The built D-dimensional NeuralQuantumStates.Lattices.Lattice of shape by using the given lattice basis and periodic boundary conditions.

source

NeuralQuantumStates.Lattices.LatticeBasis Type

LatticeBasis{T<:Real,D,O} <: NeuralQuantumStates.Lattices.AbstractLatticeBasis{T,D,O}

A lattice basis for representing the unit cell of a D-dimensional lattice with O site offsets.

Fields

• vectors::SMatrix{D,D,T}: A D$\times$D square matrix for the primitive vectors defining the unit cell.

• site_offsets::SMatrix{D,O,T}: A D$\times$O matrix for the site offsets of the lattice basis in the unit cell.

source

NeuralQuantumStates.Lattices.LatticeBasis Method

LatticeBasis(
    vectors::AbstractMatrix{T},
    site_offsets::AbstractMatrix{T}=zeros(T, size(vectors)[1], 1)
) where {T<:Real}
    -> NeuralQuantumStates.Lattices.LatticeBasis{T,size(vectors)[1],size(site_offsets)[2]}

Define a NeuralQuantumStates.Lattices.LatticeBasis for representing the unit cell of a size(vectors, 1)-dimensional lattice with the given primitive vectors and site_offsets.

Arguments

• vectors::AbstractMatrix{T}: A square matrix for the primitive vectors defining the unit cell. Each column of the matrix is a primitive vector.

• site_offsets::AbstractMatrix{T}: A matrix for the site offsets of the lattice basis in the unit cell. Each column of the matrix is a site offset vector. Defaults to zeros(T, size(vectors, 1), 1).

Returns

• NeuralQuantumStates.Lattices.LatticeBasis{T,size(vectors)[1],size(site_offsets)[2]}: The defined NeuralQuantumStates.Lattices.LatticeBasis for representing the unit cell of a size(vectors, 1)-dimensional lattice with the given primitive vectors and site_offsets.

source

NeuralQuantumStates.Lattices.LatticeBasis Method

LatticeBasis(
    vectors::AbstractMatrix{T},
    site_offset::AbstractVector{T}=zeros(T, size(vectors)[1])
) where {T<:Real} -> NeuralQuantumStates.Lattices.LatticeBasis{T,size(vectors)[1],1}

Define a NeuralQuantumStates.Lattices.LatticeBasis for representing the unit cell of a size(vectors, 1)-dimensional lattice with the given primitive vectors and site_offset.

Arguments

• vectors::AbstractMatrix{T}: A square matrix for the primitive vectors defining the unit cell. Each column of the matrix is a primitive vector.

• site_offset::AbstractVector{T}: A vector for one site offset of the lattice basis in the unit cell. Defaults to zeros(T, size(vectors)[1]).

Returns

• NeuralQuantumStates.Lattices.LatticeBasis{T,size(vectors)[1],1}: The defined NeuralQuantumStates.Lattices.LatticeBasis for representing the unit cell of a size(vectors, 1)-dimensional lattice with the given primitive vectors and site_offset.

source

NeuralQuantumStates.Lattices.LatticeBasis Method

LatticeBasis(
    vectors::AbstractVector{<:AbstractVector{T}},
    site_offsets::AbstractVector{<:AbstractVector{T}}=[zeros(T, length(vectors[1]))]
) where {T<:Real}
    -> NeuralQuantumStates.Lattices.LatticeBasis{T,length(vectors[1]),length(site_offsets)}

Define a NeuralQuantumStates.Lattices.LatticeBasis for representing the unit cell of a length(vectors[1])-dimensional lattice with the given primitive vectors and site_offsets.

Arguments

• vectors::AbstractVector{<:AbstractVector{T}}: A vector of primitive vectors defining the unit cell. Each element of the vector should be a primitive vector with the same dimension.

• site_offsets::AbstractVector{<:AbstractVector{T}}: A vector of site offsets of the lattice basis in the unit cell. Each element of the vector should be a site offset vector with the same dimension. Defaults to [zeros(T, length(vectors[1]))].

Returns

• NeuralQuantumStates.Lattices.LatticeBasis{T,length(vectors[1]),length(site_offsets)}: The defined NeuralQuantumStates.Lattices.LatticeBasis for representing the unit cell of a length(vectors[1])-dimensional lattice with the given primitive vectors and site_offsets.

source

NeuralQuantumStates.Lattices.LatticeBasis Method

LatticeBasis(
    vector::T, site_offsets::AbstractVector{T}
) where {T<:Real} -> NeuralQuantumStates.Lattices.LatticeBasis{T,1,length(site_offsets)}

Define a lattice basis for representing the unit cell of a 1D lattice with length(site_offsets) site offsets.

Arguments

• vector::T: A real number for a primitive vector defining the unit cell.

• site_offsets::AbstractVector{T}: A vector for the site offsets of the lattice basis in the unit cell.

Returns

• NeuralQuantumStates.Lattices.LatticeBasis{T,1,length(site_offsets)}: The defined lattice basis of a 1D lattice with length(site_offsets) site offsets.

source

NeuralQuantumStates.Lattices.LatticeBasis Method

LatticeBasis(vector::T, site_offset::T=T(0.0)) where {T<:Real}
    -> NeuralQuantumStates.Lattices.LatticeBasis{T,1,1}

Define a NeuralQuantumStates.Lattices.LatticeBasis for representing the unit cell of a 1D lattice with the given primitive vector and site_offset.

Arguments

• vector::T: A real number for a primitive vector defining the unit cell.

• site_offset::T: A real number for the site offset of the lattice basis in the unit cell. Defaults to T(0.0).

Returns

• NeuralQuantumStates.Lattices.LatticeBasis{T,1,1}: The defined lattice basis of a 1D lattice with the given primitive vector and site_offset.

source

NeuralQuantumStates.Lattices.build Method

build(
    ::Val{:Honeycomb},
    shape::AbstractVector{Tᵢ},
    edge_length::T;
    periodic::Union{Bool,AbstractVector{Bool}}=false,
    tol_digits::Tᵢ=TOL_DIGITS,
    dist_tol::T=DIST_TOL
) where {Tᵢ<:Integer,T<:Real} -> NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,2,1}

Build a 2D honeycomb lattice from the given parameters.

Arguments

• shape::AbstractVector{Tᵢ}: A vector for the shape of the lattice. It must contain two positive integers.

• edge_length::T: A positive number for the edge length of the lattice.

Keywords

• periodic::Union{Bool,AbstractVector{Bool}}: A boolean or a vector for the periodic boundary condition of the lattice in each dimension. If it is a boolean, then it is applied to all dimensions. If it is a vector, then it must contain two booleans. Defaults to false.

• tol_digits::Tᵢ: An integer for the number of digits to round the calculated distances to. Defaults to 12.

• dist_tol::T: A positive number for the tolerance of the distance between two lattice sites to be considered as the same site. Defaults to 1.0e-12.

Returns

• NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,2,2}: The built 2D honeycomb lattice from the given parameters.

source

NeuralQuantumStates.Lattices.build Method

build(
    ::Val{:Hypercube},
    shape::AbstractVector{Tᵢ},
    edge_length::T;
    periodic::Union{Bool,AbstractVector{Bool}}=false,
) where {Tᵢ<:Integer,T<:Real}
    -> NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,length(shape),1}

Build a hypercubic lattice from the given parameters.

Arguments

• ::Val{:Hypercube}: A value to dispatch to this function.

• shape::AbstractVector{Tᵢ}: A vector for the shape of the lattice.

• edge_length::T: A positive number for the edge length of the lattice.

Keywords

• periodic::Union{Bool,AbstractVector{Bool}}: A boolean or a vector for the periodic boundary condition of the lattice in each dimension. If it is a boolean, then it is applied to all dimensions. If it is a vector, then it must contain length(shape) booleans. Defaults to false.

Returns

• NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,length(shape),1}: The built hypercubic lattice from the given parameters.

source

NeuralQuantumStates.Lattices.build Method

build(
    ::Val{:Kagome},
    shape::AbstractVector{Tᵢ},
    edge_length::T;
    periodic::Union{Bool,AbstractVector{Bool}}=false,
    tol_digits::Tᵢ=TOL_DIGITS,
    dist_tol::T=DIST_TOL
) where {Tᵢ<:Integer,T<:Real} -> NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,2,3}

Build a 2D kagome lattice from the given parameters.

Arguments

• shape::AbstractVector{Tᵢ}: A vector for the shape of the lattice. It must contain two positive integers.

• edge_length::T: A positive number for the edge length of the lattice.

Keywords

• periodic::Union{Bool,AbstractVector{Bool}}: A boolean or a vector for the periodic boundary condition of the lattice in each dimension. If it is a boolean, then it is applied to all dimensions. If it is a vector, then it must contain two booleans. Defaults to false.

• tol_digits::Tᵢ: An integer for the number of digits to round the calculated distances to. Defaults to 12.

• dist_tol::T: A positive number for the tolerance of the distance between two lattice sites to be considered as the same site. Defaults to 1.0e-12.

Returns

• NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,2,3}: The built 2D kagome lattice from the given parameters.

source

NeuralQuantumStates.Lattices.build Method

build(
    ::Val{:Triangular},
    shape::AbstractVector{Tᵢ},
    edge_length::T;
    periodic::Union{Bool,AbstractVector{Bool}}=false,
    tol_digits::Tᵢ=TOL_DIGITS,
    dist_tol::T=DIST_TOL
) where {Tᵢ<:Integer,T<:Real} -> NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,2,1}

Build a 2D triangular lattice from the given parameters.

Arguments

• ::Val{:Triangular}: A value to dispatch to this function.

• shape::AbstractVector{Tᵢ}: A vector for the shape of the lattice. It must contain two positive integers.

• edge_length::T: A positive number for the edge length of the lattice.

Keywords

• periodic::Union{Bool,AbstractVector{Bool}}: A boolean or a vector for the periodic boundary condition of the lattice in each dimension. If it is a boolean, then it is applied to all dimensions. If it is a vector, then it must contain two booleans. Defaults to false.

• tol_digits::Tᵢ: An integer for the number of digits to round the calculated distances to. Defaults to 12.

• dist_tol::T: A positive number for the tolerance of the distance between two lattice sites to be considered as the same site. Defaults to 1.0e-12.

Returns

• NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,2,1}: The built 2D triangular lattice from the given parameters.

source

NeuralQuantumStates.Lattices.build Method

build(
    ::Val{:Triclinic},
    shape::AbstractVector{Tᵢ},
    edge_lengths::AbstractVector{T},
    angles::AbstractVector{T};
    periodic::Union{Bool,AbstractVector{Bool}}=false,
) where {Tᵢ<:Integer,T<:Real} -> NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,3,1}

Build a triclinic lattice from the given parameters.

Arguments

• ::Val{:Triclinic}: A value to dispatch to this function.

• shape::AbstractVector{Tᵢ}: A vector for the shape of the lattice. It must contain three positive integers.

• edge_lengths::AbstractVector{T}: A vector for the edge lengths of the lattice. It must contain three positive numbers.

• angles::AbstractVector{T}: A vector for the angles in degrees between the edge lengths of the lattice. It must contain three numbers. angles[i] is the angle between edge_lengths[j] and edge_lengths[k] where (i,j,k) is a permutation of (1,2,3).

Keywords

• periodic::Union{Bool,AbstractVector{Bool}}: A boolean or a vector for the periodic boundary condition of the lattice in each dimension. If it is a boolean, then it is applied to all dimensions. If it is a vector, then it must contain three booleans. Defaults to false.

Returns

• NeuralQuantumStates.Lattices.Lattice{Tᵢ,T,3,1}: The built triclinic lattice from the given parameters.

source

NeuralQuantumStates.Hilberts.CompositeSumConstraint Type

CompositeSumConstraint{T<:Real,N_HS}
    <: NeuralQuantumStates.Hilberts.CompositeDiscreteHilbertConstraint

source

NeuralQuantumStates.Hilberts.CompositeUniformHilbert Type

CompositeUniformHilbert{T_C_Array<:AbstractArray,N,N_DoF} <:
NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF}

A composite uniform Hilbert space.

Fields

• hilberts::NTuple{N,NeuralQuantumStates.Hilberts.UniformHilbert}: Uniform Hilbert spaces to be composed.

• constraint::NeuralQuantumStates.Hilberts.AbstractCompositeDiscreteHilbertConstraint: A constraint to the composite uniform Hilbert space.

source

NeuralQuantumStates.Hilberts.FiniteUniformHilbert Type

FiniteUniformHilbert{T<:Real,T_Array<:AbstractArray,N_DoF,N_lDoF}
    <: NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF}

A finite uniform Hilbert space.

Fields

• lDoF::SVector{N_lDoF,T}: Local degrees of freedom.

• constraint::NeuralQuantumStates.Hilberts.AbstractDiscreteHilbertConstraint: A constraint to the uniform Hilbert space.

• type::Symbol: The type of the uniform Hilbert space.

source

NeuralQuantumStates.Hilberts.InfiniteUniformHilbert Type

InfiniteUniformHilbert{T<:Real,T_Array<:AbstractArray,N_DoF}
    <: NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF}

An infinite uniform Hilbert space.

Fields

• type::Symbol: The type of the uniform Hilbert space.

source

NeuralQuantumStates.Hilberts.NoCompositeDiscreteHilbertConstraint Type

NoCompositeDiscreteHilbertConstraint
    <: NeuralQuantumStates.Hilberts.AbstractCompositeDiscreteHilbertConstraint

A constraint that does not introduce any constraint to the composite discrete Hilbert space.

source

NeuralQuantumStates.Hilberts.NoDiscreteHilbertConstraint Type

NoDiscreteHilbertConstraint <: NeuralQuantumStates.Hilberts.AbstractDiscreteHilbertConstraint

A constraint that does not introduce any constraint to the discrete Hilbert space.

source

NeuralQuantumStates.Hilberts.SumConstraint Type

SumConstraint{T<:Real}(sum_value::T)
    <: NeuralQuantumStates.Hilberts.DiscreteHilbertConstraint

A constraint introducing that the sum of the elements of a given state is equal to a given value.

Fields

• sum_value::T: The value that the sum of the elements of a given state must be equal to.

source

NeuralQuantumStates.Hilberts.:⊗ Method

⊗(
    (hilberts::NeuralQuantumStates.Hilberts.UniformHilbert)...;
    constraint::NeuralQuantumStates.Hilberts.AbstractCompositeDiscreteHilbertConstraint=NeuralQuantumStates.Hilberts.NoCompositeDiscreteHilbertConstraint(),
    array_type::Type=Array
) -> NeuralQuantumStates.Hilberts.CompositeUniformHilbert

Return a composite uniform Hilbert space by taking the tensor product of the given uniform Hilbert spaces.

Arguments

• hilberts::NeuralQuantumStates.Hilberts.UniformHilbert: The uniform Hilbert spaces to be tensor producted.

• constraint::NeuralQuantumStates.Hilberts.AbstractCompositeDiscreteHilbertConstraint: The composite constraint to be applied. Default is NeuralQuantumStates.Hilberts.NoCompositeDiscreteHilbertConstraint().

• array_type::Type: The Vector type to be used in each state. Default is Array.

Returns

• NeuralQuantumStates.Hilberts.CompositeUniformHilbert: The generated composite uniform Hilbert space.

source

NeuralQuantumStates.Hilberts.all_states Method

all_states(hilbert::NeuralQuantumStates.Hilberts.CompositeUniformHilbert{T_C_Array,N,N_DoF}) where
    {T_C_Array<:AbstractArray,N,N_DoF} -> Vector{NTuple}

Return all states in the given composite uniform Hilbert space.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.CompositeUniformHilbert{T_C_Array,N,N_DoF}: The composite uniform Hilbert space.

Returns

• Vector{T_C_Array}: All states in the given composite uniform Hilbert space.

source

NeuralQuantumStates.Hilberts.all_states Method

all_states(
    hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T,T_Array,N_DoF,N_lDoF}
) where {T<:Real,T_Array<:AbstractArray,N_DoF,N_lDoF} -> Vector{Vector}

Return all states in the given finite uniform Hilbert space.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T,T_Array,N_DoF,N_lDoF}: The finite uniform Hilbert space.

Returns

• Vector{T_Array}: All states in the given finite uniform Hilbert space.

source

NeuralQuantumStates.Hilberts.all_states Method

all_states(hilbert::Hilberts.InfiniteUniformHilbert{T,T_Array,N_DoF}) where
    {T<:Real,T_Array<:AbstractArray,N_DoF}

Throws an OverflowError since the Hilbert space is infinite.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.InfiniteUniformHilbert{T,T_Array,N_DoF}: The infinite uniform Hilbert space.

source

NeuralQuantumStates.Hilberts.build Method

build(::Val{:Qubit}, N::Integer, array_type::Type=Array) where {T<:Integer}
    -> NeuralQuantumStates.Hilberts.FiniteUniformHilbert

Build a finite uniform Hilbert space for a qubit system.

Arguments

• N::Integer: Number of degrees of freedom.

• array_type::Type: The Vector type to be used in each state. Default is Array.

Returns

• NeuralQuantumStates.Hilberts.FiniteUniformHilbert: The finite uniform Hilbert space for a qubit system.

source

NeuralQuantumStates.Hilberts.build Method

build(
    ::Val{:Spin}, s::T, N::Integer;
    ∑Sz::Union{T_Sz,Nothing}=nothing, array_type::Type=Array
) where {T<:Union{Rational,Integer},T_Sz<:Real}
    -> NeuralQuantumStates.Hilberts.FiniteUniformHilbert

Build a finite uniform Hilbert space for a spin-s system.

Arguments

• s::T: Spin of the system.

• N::Integer: Number of degrees of freedom.

• ∑Sz::Union{T_Sz,Nothing}: The total magnetization to be conserved. Default is nothing.

• array_type::Type: The Vector type to be used in each state. Default is Array.

Returns

• NeuralQuantumStates.Hilberts.FiniteUniformHilbert: The finite uniform Hilbert space for a spin-s system.

source

NeuralQuantumStates.Hilberts.build Method

build(
    ::Val{:Fock}, n_max::T, N::Integer;
    ∑n::Union{T_n,Nothing}=nothing, array_type::Type=Array
) where {T<:Integer,T_n<:Real} -> NeuralQuantumStates.Hilberts.FiniteUniformHilbert

Build a finite uniform Hilbert space for a Fock system.

Arguments

• n_max::T: Allowed maximum number of particles in each lattice site.

• N::Integer: Number of degrees of freedom.

• ∑n::Union{T_n,Nothing}: The total number of particles to be conserved. Default is nothing.

• array_type::Type: The Vector type to be used in each state. Default is Array.

Returns

• NeuralQuantumStates.Hilberts.FiniteUniformHilbert: The finite uniform Hilbert space for a Fock system.

source

NeuralQuantumStates.Hilberts.check Method

check(
    constraint::NeuralQuantumStates.Hilberts.NoCompositeDiscreteHilbertConstraint,
    x::AbstractVector{AbstractVector}
) -> Bool

Always return true if there is no composite discrete Hilbert space constraint.

Arguments

• constraint::NeuralQuantumStates.Hilberts.NoCompositeDiscreteHilbertConstraint: A NeuralQuantumStates.Hilberts.NoCompositeDiscreteHilbertConstraint object.

• x::AbstractVector{AbstractVector}: A composite state to be checked.

Returns

• Bool: Always true.

source

NeuralQuantumStates.Hilberts.check Method

check(
    constraint::NeuralQuantumStates.Hilberts.CompositeSumConstraint{T,N_HS},
    x::AbstractVector{AbstractVector}
) where {T<:Real,N_HS} -> Bool

Check if the sum of the elements of a given composite state is equal to the given sum values.

Arguments

• constraint::NeuralQuantumStates.Hilberts.CompositeSumConstraint{T,N_HS}: A NeuralQuantumStates.Hilberts.CompositeSumConstraint object.

• x::AbstractVector{AbstractVector}: A composite state to be checked.

Returns

• Bool: true if the sum of the elements of the given composite state is equal to the given sum values.

source

NeuralQuantumStates.Hilberts.check Method

check(
    constraint::NeuralQuantumStates.Hilberts.NoDiscreteHilbertConstraint,
    x::AbstractVector{T_lDoF}
) where {T_lDoF<:Real} -> Bool

Always return true if there is no Hilbert space constraint.

Arguments

• constraint::NeuralQuantumStates.Hilberts.NoDiscreteHilbertConstraint: A NeuralQuantumStates.Hilberts.NoDiscreteHilbertConstraint object.

• x::AbstractVector{T_lDoF}: A state to be checked.

Returns

• Bool: Always true.

source

NeuralQuantumStates.Hilberts.check Method

check(
    constraint::NeuralQuantumStates.Hilberts.SumConstraint{T}, x::AbstractVector{T_lDoF}
) where {T<:Real,T_lDoF<:Real} -> Bool

Check if the sum of the elements of a given state is equal to the given sum value.

Arguments

• constraint::NeuralQuantumStates.Hilberts.SumConstraint{T}: A NeuralQuantumStates.Hilberts.SumConstraint object.

• x::AbstractVector{T_lDoF}: A state to be checked.

Returns

• Bool: true if the sum of the elements of the given state is equal to the given sum value.

source

NeuralQuantumStates.Hilberts.n_DoF Method

n_DoF(hilbert::NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF}) where {N_DoF}
    -> typeof(N_DoF)

Get the number of degrees of freedom of the given uniform Hilbert space.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF}: A uniform Hilbert space.

Returns

• typeof(N_DoF): The number of degrees of freedom of the given uniform Hilbert space.

source

NeuralQuantumStates.Hilberts.n_lDoF Method

n_lDoF(
    hilbert::NeuralQuantumStates.Hilberts.CompositeUniformHilbert{T_C_Array,N,N_DoF},
    dof_index::integer
) where {T_C_Array<:AbstractArray,N,N_DoF} -> Integer

Get the number of local degrees of freedom of the given composite uniform Hilbert space at the given degree of freedom index.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.CompositeUniformHilbert{T_C_Array,N,N_DoF}: A composite uniform Hilbert space.

• dof_index::Integer: A degree of freedom index.

Returns

• Integer: The number of local degrees of freedom of the given composite uniform Hilbert space at the given degree of freedom index.

source

NeuralQuantumStates.Hilberts.n_lDoF Method

n_lDoF(hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T,T_Array,N_DoF,N_lDoF})
    where {T<:Real,T_Array<:AbstractArray,N_DoF,N_lDoF} -> typeof(N_lDoF)

Get the number of local degrees of freedom of the given finite uniform Hilbert space.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T,T_Array,N_DoF,N_lDoF}: A finite uniform Hilbert space.

Returns

• typeof(N_lDoF): The number of local degrees of freedom of the given finite uniform Hilbert space.

source

NeuralQuantumStates.Hilberts.n_lDoF Method

n_lDoF(hilbert::NeuralQuantumStates.Hilberts.InfiniteUniformHilbert{T,T_Array,N_DoF})
    where {T<:Real,T_Array<:AbstractArray,N_DoF} -> typeof(N_DoF)

Throws an OverflowError since the number of local degrees of freedom of an infinite uniform Hilbert space is infinite.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.InfiniteUniformHilbert{T,T_Array,N_DoF}: An infinite uniform Hilbert space.

source

NeuralQuantumStates.Hilberts.n_states Method

n_states(hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T,N_DoF,N_lDoF})
    where {T<:Real,N_DoF,N_lDoF} -> Integer

Get the number of states of the given finite uniform Hilbert space.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T,N_DoF,N_lDoF}: A finite uniform Hilbert space.

Returns

• Integer: The number of states of the given finite uniform Hilbert space.

source

NeuralQuantumStates.Hilberts.n_states Method

n_states(hilbert::NeuralQuantumStates.Hilberts.InfiniteUniformHilbert{T,T_Array,N_DoF})
    where {T<:Real,T_Array<:AbstractArray,N_DoF} -> Integer

Throws an OverflowError since the number of states of an infinite uniform Hilbert space is infinite.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.InfiniteUniformHilbert{T,T_Array,N_DoF}: An infinite uniform Hilbert space.

source

NeuralQuantumStates.Hilberts.state_index_to_state Method

state_index_to_state(
    hilbert::NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF},
    indices::AbstractVector{Int}
) where {N_DoF} -> Vector{NTuple}

Return the states corresponding to the given indices in the given uniform Hilbert space.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF}: The uniform Hilbert space.

• indices::AbstractVector{Int}: The indices of the states to be returned in the state representation.

Returns

• Vector{Vector}: A vector of states corresponding to the given indices in the state representation.

source

NeuralQuantumStates.Hilberts.state_index_to_state Method

state_index_to_state(
    hilbert::NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF}, index::Int
) where {N_DoF} -> NTuple

Return the state corresponding to the given index in the given uniform Hilbert space.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF}: The uniform Hilbert space.

• index::AbstractVector{Int}: The index of the state to be returned in the state representation.

Returns

• Array: A state corresponding to the given index in the state representation.

source

NeuralQuantumStates.Hilberts.state_to_state_index Method

state_to_state_index(
    hilbert::NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF},
    states::AbstractVector{<:AbstractVector{T}}
) where {N_DoF,T<:Real} -> Vector{Integer}

Return the indices of the given states in the given uniform Hilbert space.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF}: The uniform Hilbert space.

• states::AbstractVector{<:AbstractVector{T}}: The states to be returned in the index representation.

Returns

• Vector{Integer}: A vector of indices of the given states in the index representation.

source

NeuralQuantumStates.Hilberts.state_to_state_index Method

state_to_state_index(
    hilbert::NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF},
    state::AbstractVector{T}
) where {N_DoF,T<:Real} -> Integer

Return the index of the given state in the given uniform Hilbert space.

Arguments

• hilbert::NeuralQuantumStates.Hilberts.UniformHilbert{N_DoF}: The uniform Hilbert space.

• state::AbstractVector{T}: The state to be returned in the index representation.

Returns

• Integer: The index of the given state in the index representation.

source

NeuralQuantumStates.Operators.BoseHubbardOperator Type

BoseHubbardOperator{
    T<:DEFAULT_bosehubbard_T,
    T_h<:DEFAULT_bosehubbard_T_h,
    T_h_Array<:DEFAULT_bosehubbard_T_h_Array,
    Tᵢ<:DEFAULT_bosehubbard_Tᵢ,
    T_l<:DEFAULT_bosehubbard_T_l,
    T_p<:DEFAULT_bosehubbard_T_p,
    N,n_lDoF,D,O
}(
    hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T_h,T_h_Array,N,n_lDoF},
    lattice::NeuralQuantumStates.Lattices.Lattice{Tᵢ,T_l,D,O},
    J::T_p,
    U::T_p,
    V::T_p,
    μ::T_p
) <: NeuralQuantumStates.Operators.DiscreteOperator{T}

Extended Bose-Hubbard operator instance according to the following formula: $\hat{H}=-J\sum _{⟨i,j⟩}({\hat{b}}_i^{†}{\hat{b}}_j+\mathrm{h}.\mathrm{c}.)+\frac{U}{2}\sum _i{\hat{n}}_i({\hat{n}}_i-1)+V\sum _{⟨i,j⟩}{\hat{n}}_i{\hat{n}}_j+\mu \sum _i{\hat{n}}_i$

Fields

• hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T_h,T_h_Array,N,n_lDoF}: An instance of NeuralQuantumStates.Hilberts.FiniteUniformHilbert.

• lattice::NeuralQuantumStates.Lattices.Lattice{Tᵢ,T_l,D,O}: An instance of NeuralQuantumStates.Lattices.Lattice.

• J::T_p: Hopping amplitude.

• U::T_p: On-site interaction strength.

• V::T_p: Extended-range interaction strength.

• μ::T_p: Chemical potential.

source

NeuralQuantumStates.Operators.TransverseFieldIsingOperator Type

TransverseFieldIsingOperator{
    T<:DEFAULT_ising_T,
    T_h<:DEFAULT_ising_T_h,
    T_h_Array<:DEFAULT_ising_T_h_Array,
    Tᵢ<:DEFAULT_ising_Tᵢ,
    T_l<:DEFAULT_ising_T_l,
    T_p<:DEFAULT_ising_T_p,
    N,n_lDoF,D,O
}(
    hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T_h,T_h_Array,N,n_lDoF}
    lattice::NeuralQuantumStates.Lattices.Lattice{Tᵢ,T_l,D,O}
    J::T_p
    h_x::T_p
    h_z::T_p
) <: NeuralQuantumStates.Operators.DiscreteOperator{T}

Transverse-field Ising operator instance according to the following formula: $\hat{H}=J\sum _{⟨i,j⟩}\left({\hat{\sigma }}_i^z{\hat{\sigma }}_j^z\right)+h_x\sum _i{\hat{\sigma }}_i^x+h_z\sum _i{\hat{\sigma }}_i^z$

Fields

• hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T_h,T_h_Array,N,n_lDoF}: An instance of NeuralQuantumStates.Hilberts.FiniteUniformHilbert.

• lattice::NeuralQuantumStates.Lattices.Lattice{Tᵢ,T_l,D,O}: An instance of NeuralQuantumStates.Lattices.Lattice.

• J::T_p: Coupling constant.

• h_x::T_p: Transverse-field strength.

• h_z::T_p: Strength of external magnetic field.

source

NeuralQuantumStates.Operators.build Method

build(
    ::Val{:ExtendedBoseHubbard},
    hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T_h,T_h_Array,N,n_lDoF},
    lattice::NeuralQuantumStates.Lattices.Lattice{Tᵢ,T_l,D,O};
    J::T_p=1.0, U::T_p=1.0, V::T_p=1.0, μ::T_p=0.0, T=Float64
) where {
    T_h<:DEFAULT_bosehubbard_T_h,
    T_h_Array<:DEFAULT_bosehubbard_T_h_Array,
    Tᵢ<:DEFAULT_bosehubbard_Tᵢ,
    T_l<:DEFAULT_bosehubbard_T_l,
    T_p<:DEFAULT_bosehubbard_T_p,
    N,n_lDoF,D,O
}

Build an extended Bose-Hubbard operator from the given parameters according to the following formula: $\hat{H}=-J\sum _{⟨i,j⟩}({\hat{b}}_i^{†}{\hat{b}}_j+\mathrm{h}.\mathrm{c}.)+\frac{U}{2}\sum _i{\hat{n}}_i({\hat{n}}_i-1)+V\sum _{⟨i,j⟩}{\hat{n}}_i{\hat{n}}_j+\mu \sum _i{\hat{n}}_i$

Arguments

• ::Val{:ExtendedBoseHubbard}: A value to dispatch to this function.

• hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T_h,T_h_Array,N,n_lDoF}: An instance of NeuralQuantumStates.Hilberts.FiniteUniformHilbert.

• lattice::NeuralQuantumStates.Lattices.Lattice{Tᵢ,T_l,D,O}: An instance of NeuralQuantumStates.Lattices.Lattice.

Keywords

• J::T_p: Hopping amplitude. Defaults to 1.0.

• U::T_p: On-site interaction strength. Defaults to 1.0.

• V::T_p: Extended-range interaction strength. Defaults to 1.0.

• μ::T_p: Chemical potential. Defaults to 0.0.

• T::DataType: Type of numbers in the operator. Defaults to Float64.

source

NeuralQuantumStates.Operators.build Method

build(
    ::Val{:TransverseFieldIsing},
    hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T_h,T_h_Array,N,n_lDoF},
    lattice::NeuralQuantumStates.Lattices.Lattice{Tᵢ,T_l,D,O};
    J::T_p=1.0, h_x::T_p=1.0, h_z::T_p=1.0, T::DataType=Float64
) where {
    T_h<:DEFAULT_ising_T_h,
    T_h_Array<:DEFAULT_ising_T_h_Array,
    Tᵢ<:DEFAULT_ising_Tᵢ,
    T_l<:DEFAULT_ising_T_l,
    T_p<:DEFAULT_ising_T_p,
    N,n_lDoF,D,O
}

Build a transverse-field Ising operator from the given parameters according to the following formula: $\hat{H}=J\sum _{⟨i,j⟩}\left({\hat{\sigma }}_i^z{\hat{\sigma }}_j^z\right)+h_x\sum _i{\hat{\sigma }}_i^x+h_z\sum _i{\hat{\sigma }}_i^z$

Arguments

• ::Val{:TransverseFieldIsing}: A value to dispatch to this function.

• hilbert::NeuralQuantumStates.Hilberts.FiniteUniformHilbert{T_h,T_h_Array,N,n_lDoF}: An instance of NeuralQuantumStates.Hilberts.FiniteUniformHilbert.

• lattice::NeuralQuantumStates.Lattices.Lattice{Tᵢ,T_l,D,O}: An instance of NeuralQuantumStates.Lattices.Lattice.

Keywords

• J::T_p: Coupling constant. Defaults to 1.0.

• h_x::T_p: Transverse-field strength. Defaults to 1.0.

• h_z::T_p: Strength of external magnetic field. Defaults to 1.0.

source

NeuralQuantumStates.Operators.connected_basis_configs Method

connected_basis_configs(
    operator::NeuralQuantumStates.Operators.BoseHubbardOperator{
        T,T_h,T_h_Array,Tᵢ,T_l,T_p,N,n_lDoF,D,O
    },
    samples::AbstractArray{T_h};
    kwargs...
) where {
    T<:DEFAULT_bosehubbard_T,
    T_h<:DEFAULT_bosehubbard_T_h,
    T_h_Array<:DEFAULT_bosehubbard_T_h_Array,
    Tᵢ<:DEFAULT_bosehubbard_Tᵢ,
    T_l<:DEFAULT_bosehubbard_T_l,
    T_p<:DEFAULT_bosehubbard_T_p,
    N,n_lDoF,D,O
}

Return the connected basis configurations $|s^{\prime }⟩$ to a given operator $\hat{O}$, i.e. operator, for given configurations $|s⟩$, i.e. samples, with their matrix elements $⟨s^{\prime }|\hat{O}|s⟩$. For this function, samples needs to be a $\cdots \times N$ array (or tensor) contains the given configurations.

Arguments

• operator::NeuralQuantumStates.Operators.BoseHubbardOperator{ T,T_h,T_h_Array,Tᵢ,T_l,T_p,N,n_lDoF,D,O}: An instance of NeuralQuantumStates.Operators.BoseHubbardOperator.

• samples::AbstractArray{T_h}: A $\cdots \times N$ array (or tensor) of the representative vectors for the given basis configurations.

Returns

• T_h_Array{Union{T_h,Missing}, ndims(samples) + 1}: A $M_{\max }\times \cdots \times N$ array (or tensor) of connected basis configurations where $M_{\max }$ is the maximum of connections for each given configuration. Each element of the constructed configurations as extra will be assigned as missing.

• Array{T, ndims(samples)}: A $M_{\max }\times \dots$ array or (tensor) of matrix elements $⟨s^{\prime }|\hat{O}|s⟩$. Each matrix elements will be assigned as missing.

source

NeuralQuantumStates.Operators.connected_basis_configs Method

connected_basis_configs(
    operator::NeuralQuantumStates.Operators.BoseHubbardOperator{
        T,T_h,T_h_Array,Tᵢ,T_l,T_p,N,n_lDoF,D,O
    },
    samples::AbstractVector{<:AbstractVector{T_h}};
    kwargs...
) where {
    T<:DEFAULT_bosehubbard_T,
    T_h<:DEFAULT_bosehubbard_T_h,
    T_h_Array<:DEFAULT_bosehubbard_T_h_Array,
    Tᵢ<:DEFAULT_bosehubbard_Tᵢ,
    T_l<:DEFAULT_bosehubbard_T_l,
    T_p<:DEFAULT_bosehubbard_T_p,
    N,n_lDoF,D,O
}

Return the connected basis configurations $|s^{\prime }⟩$ to a given operator $\hat{O}$, i.e. operator, for given configurations $|s⟩$, i.e. samples, with their matrix elements $⟨s^{\prime }|\hat{O}|s⟩$. For this function, samples needs to be a vector of vectors that contains the given configurations.

Arguments

• operator::NeuralQuantumStates.Operators.BoseHubbardOperator{ T,T_h,T_h_Array,Tᵢ,T_l,T_p,N,n_lDoF,D,O}: An instance of NeuralQuantumStates.Operators.BoseHubbardOperator.

• samples::AbstractVector{<:AbstractVector{T_h}}: The representative vectors for the given basis configurations.

Returns

• Vector{Tuple{T_h_Array{Union{T_h,Missing}, 2}, Vector{T}}}: The $N\times M_i$ matrices of $M_i$ connected basis configurations and the vectors of M_i matrix elements $⟨s^{\prime }|\hat{O}|s⟩$ for each the $i$-th element of samples.

source

NeuralQuantumStates.Operators.connected_basis_configs Method

connected_basis_configs(
    operator::NeuralQuantumStates.Operators.BoseHubbardOperator{
        T,T_h,T_h_Array,Tᵢ,T_l,T_p,N,n_lDoF,D,O
    },
    sample::AbstractVector{T_h}
) where {
    T<:DEFAULT_bosehubbard_T,
    T_h<:DEFAULT_bosehubbard_T_h,
    T_h_Array<:DEFAULT_bosehubbard_T_h_Array,
    Tᵢ<:DEFAULT_bosehubbard_Tᵢ,
    T_l<:DEFAULT_bosehubbard_T_l,
    T_p<:DEFAULT_bosehubbard_T_p,
    N,n_lDoF,D,O
}

Return the connected basis configurations $|s^{\prime }⟩$ to a given operator $\hat{O}$, i.e. operator, for a given configuration $|s⟩$, i.e. sample, with their matrix elements $⟨s^{\prime }|\hat{O}|s⟩$. For this function, sample needs to be a vector that contains only one configuration.

Arguments

• operator::NeuralQuantumStates.Operators.BoseHubbardOperator{ T,T_h,T_h_Array,Tᵢ,T_l,T_p,N,n_lDoF,D,O}: An instance of NeuralQuantumStates.Operators.BoseHubbardOperator.

• sample::AbstractVector{T_h}: A representative vector for the given basis configuration.

Returns

• T_h_Array{Union{T_h,Missing}, 2}: A $N\times M$ matrix of $M$ connected basis configurations.

• Vector{T}: A vector of $M$ matrix elements $⟨s^{\prime }|\hat{O}|s⟩$.

source

NeuralQuantumStates.Operators.connected_basis_configs Method

connected_basis_configs(
    operator::NeuralQuantumStates.Operators.TransverseFieldIsingOperator{
        T,T_h,T_h_Array,Tᵢ,T_l,T_p,N,n_lDoF,D,O
    },
    samples::AbstractArray{T_h};
) where {
    T<:DEFAULT_ising_T,
    T_h<:DEFAULT_ising_T_h,
    T_h_Array<:DEFAULT_ising_T_h_Array,
    Tᵢ<:DEFAULT_ising_Tᵢ,
    T_l<:DEFAULT_ising_T_l,
    T_p<:DEFAULT_ising_T_p,
    N,n_lDoF,D,O
}

Return the connected basis configurations $|s^{\prime }⟩$ to a given operator $\hat{O}$, i.e. operator, for given configurations $|s⟩$, i.e. samples, with their matrix elements $⟨s^{\prime }|\hat{O}|s⟩$. For this function, samples needs to be a $\cdots \times N$ array (or tensor) contains the given configurations.

Arguments

• operator::NeuralQuantumStates.Operators.TransverseFieldIsingOperator{ T,T_h,T_h_Array,Tᵢ,T_l,T_p,N,n_lDoF,D,O}: An instance of NeuralQuantumStates.Operators.TransverseFieldIsingOperator.

• samples::AbstractArray{T_h}: A $\cdots \times N$ array (or tensor) of the representative vectors for the given basis configurations.

Returns

• T_h_Array{Union{T_h,Missing}, ndims(samples) + 1}: A $M_{\max }\times \cdots \times N$ array (or tensor) of connected basis configurations where $M_{\max }$ is the maximum of connections for each given configuration. Each element of the constructed configurations as extra will be assigned as missing.

• Array{T, ndims(samples)}: A $M_{\max }\times \dots$ array or (tensor) of matrix elements $⟨s^{\prime }|\hat{O}|s⟩$. Each matrix elements will be assigned as missing.

source

NeuralQuantumStates.Operators.connected_basis_configs Method

connected_basis_configs(
    operator::NeuralQuantumStates.Operators.TransverseFieldIsingOperator{
        T,T_h,T_h_Array,Tᵢ,T_l,T_p,N,n_lDoF,D,O
    },
    samples::AbstractVector{<:AbstractVector{T_h}};
    kwargs...
) where {
    T<:DEFAULT_ising_T,
    T_h<:DEFAULT_ising_T_h,
    T_h_Array<:DEFAULT_ising_T_h_Array,
    Tᵢ<:DEFAULT_ising_Tᵢ,
    T_l<:DEFAULT_ising_T_l,
    T_p<:DEFAULT_ising_T_p,
    N,n_lDoF,D,O
}

Return the connected basis configurations $|s^{\prime }⟩$ to a given operator $\hat{O}$, i.e. operator, for given configurations $|s⟩$, i.e. samples, with their matrix elements $⟨s^{\prime }|\hat{O}|s⟩$. For this function, samples needs to be a vector of vectors that contains the given configurations.

Arguments

• operator::NeuralQuantumStates.Operators.TransverseFieldIsingOperator{ T,T_h,T_h_Array,Tᵢ,T_l,T_p,N,n_lDoF,D,O}: An instance of NeuralQuantumStates.Operators.TransverseFieldIsingOperator.

• samples::AbstractVector{<:AbstractVector{T_h}}: The representative vectors for the given basis configurations.

Returns

• Vector{Tuple{T_h_Array{Union{T_h,Missing}, 2}, Vector{T}}}: The $N\times M_i$ matrices of $M_i$ connected basis configurations and the vectors of $M_i$ matrix elements $⟨s^{\prime }|\hat{O}|s⟩$ for each the $i$-th element of samples.

source

NeuralQuantumStates.Operators.connected_basis_configs Method

connected_basis_configs(
    operator::NeuralQuantumStates.Operators.TransverseFieldIsingOperator{
        T,T_h,T_h_Array,Tᵢ,T_l,T_p,N,n_lDoF,D,O
    },
    sample::AbstractVector{T_h}
) where {
    T<:DEFAULT_ising_T,
    T_h<:DEFAULT_ising_T_h,
    T_h_Array<:DEFAULT_ising_T_h_Array,
    Tᵢ<:DEFAULT_ising_Tᵢ,
    T_l<:DEFAULT_ising_T_l,
    T_p<:DEFAULT_ising_T_p,
    N,n_lDoF,D,O
}

Return the connected basis configurations $|s^{\prime }⟩$ to a given operator $\hat{O}$, i.e. operator, for a given configuration $|s⟩$, i.e. sample, with their matrix elements $⟨s^{\prime }|\hat{O}|s⟩$. For this function, sample needs to be a vector that contains only one configuration.

Arguments

• operator::NeuralQuantumStates.Operators.TransverseFieldIsingOperator{ T,T_h,T_h_Array,Tᵢ,T_l,T_p,N,n_lDoF,D,O}: An instance of NeuralQuantumStates.Operators.TransverseFieldIsingOperator.

• sample::AbstractVector{T_h}: A representative vector for the given basis configuration.

Returns

• T_h_Array{Union{T_h,Missing}, 2}: A $N\times M$ matrix of $M$ connected basis configurations.

• Vector{T}: A vector of $M$ matrix elements $⟨s^{\prime }|\hat{O}|s⟩$.

source