Index

An Index represents a single tensor index with fixed dimension dim. Copies of an Index compare equal unless their tags are different.

An Index carries a TagSet, a set of tags which are small strings that specify properties of the Index to help distinguish it from other Indices. There is a special tag which is referred to as the integer tag or prime level which can be incremented or decremented with special priming functions.

Internally, an Index has a fixed id number, which is how the ITensor library knows two indices are copies of a single original Index. Index objects must have the same id, as well as the tags to compare equal.

A QN Index is an Index with QN block storage instead of just an integer dimension. The QN block storage is a vector of pairs of QNs and block dimensions. The total dimension of a QN Index is the sum of the dimensions of the blocks of the Index.

Index(dim::Int; tags::Union{AbstractString, TagSet} = "",
                plev::Int = 0)

Create an Index with a unique id, a TagSet given by tags, and a prime level plev.

Examples

julia> i = Index(2; tags = "l", plev = 1)
(dim=2|id=818|"l")'

julia> dim(i)
2

julia> plev(i)
1

julia> tags(i)
"l"

Index(dim::Integer, tags::Union{AbstractString, TagSet}; plev::Int = 0)

Create an Index with a unique id and a tagset given by tags.

Examples

julia> i = Index(2, "l,tag")
(dim=2|id=58|"l,tag")

julia> dim(i)
2

julia> plev(i)
0

julia> tags(i)
"l,tag"

Index(qnblocks::Pair{QN, Int64}...; dir::Arrow = Out,
                                    tags = "",
                                    plev::Integer = 0)

Construct a QN Index from a list of pairs of QN and block dimensions.

Example

Index(QN("Sz", -1) => 1, QN("Sz", 1) => 1; tags = "i")

Index(qnblocks::Vector{Pair{QN, Int64}}; dir::Arrow = Out,
                                         tags = "",
                                         plev::Integer = 0)

Construct a QN Index from a Vector of pairs of QN and block dimensions.

Note: in the future, this may enforce that all blocks have the same QNs (which would allow for some optimizations, for example when constructing random QN ITensors).

Example

Index([QN("Sz", -1) => 1, QN("Sz", 1) => 1]; tags = "i")

Index(qnblocks::Vector{Pair{QN, Int64}}, tags; dir::Arrow = Out,
                                               plev::Integer = 0)

Construct a QN Index from a Vector of pairs of QN and block dimensions.

Example

Index([QN("Sz", -1) => 1, QN("Sz", 1) => 1], "i"; dir = In)

id(i::Index)

Obtain the id of an Index, which is a unique 64 digit integer.

hasid(i::Index, id::ITensors.IDType)

Check if an Index i has the provided id.

Examples

julia> i = Index(2)
(dim=2|id=321)

julia> hasid(i, id(i))
true

julia> j = Index(2)
(dim=2|id=17)

julia> hasid(i, id(j))
false

tags(i::Index)

Obtain the TagSet of an Index.

hastags(i::Index, ts::Union{AbstractString,TagSet})

Check if an Index i has the provided tags, which can be a string of comma-separated tags or a TagSet object.

Examples

julia> i = Index(2, "SpinHalf,Site,n=3")
(dim=2|id=861|"Site,SpinHalf,n=3")

julia> hastags(i, "SpinHalf,Site")
true

julia> hastags(i, "Link")
false

plev(i::Index)

Obtain the prime level of an Index.

hasplev(i::Index, plev::Int)

Check if an Index i has the provided prime level.

Examples

julia> i = Index(2; plev=2)
(dim=2|id=543)''

julia> hasplev(i, 2)
true

julia> hasplev(i, 1)
false

dim(i::Index)

Obtain the dimension of an Index.

For a QN Index, this is the sum of the block dimensions.

==(i1::Index, i1::Index)

Compare indices for equality. First the id's are compared, then the prime levels are compared, and finally the tags are compared.

dir(i::Index)

Obtain the direction of an Index (In, Out, or Neither).

hasqns(::Index)

Checks of the Index has QNs or not.

prime(i::Index, plinc::Int = 1)

Return a copy of Index i with its prime level incremented by the amount plinc

adjoint(i::Index)

Prime an Index using the notation i'.

^(i::Index, pl::Int)

Prime an Index using the notation i^3.

setprime(i::Index, plev::Int)

Return a copy of Index i with its prime level set to plev

noprime(i::Index)

Return a copy of Index i with its prime level set to zero.

settags(i::Index, ts)

Return a copy of Index i with tags replaced by the ones given The ts argument can be a comma-separated string of tags or a TagSet.

Examples

julia> i = Index(2, "SpinHalf,Site,n=3")
(dim=2|id=543|"Site,SpinHalf,n=3")

julia> hastags(i, "Link")
false

julia> j = settags(i,"Link,n=4")
(dim=2|id=543|"Link,n=4")

julia> hastags(j, "Link")
true

julia> hastags(j, "n=4,Link")
true

addtags(i::Index,ts)

Return a copy of Index i with the specified tags added to the existing ones. The ts argument can be a comma-separated string of tags or a TagSet.

removetags(i::Index, ts)

Return a copy of Index i with the specified tags removed. The ts argument can be a comma-separated string of tags or a TagSet.

replacetags(i::Index, tsold, tsnew)

replacetags(i::Index, tsold => tsnew)

If the tag set of i contains the tags specified by tsold, replaces these with the tags specified by tsnew, preserving any other tags. The arguments tsold and tsnew can be comma-separated strings of tags, or TagSet objects.

Examples

julia> i = Index(2; tags = "l,x", plev = 1)
(dim=2|id=83|"l,x")'

julia> replacetags(i, "l", "m")
(dim=2|id=83|"m,x")'

julia> replacetags(i, "l" => "m")
(dim=2|id=83|"m,x")'

sim(i::Index; tags = tags(i), plev = plev(i), dir = dir(i))

Produces an Index with the same properties (dimension or QN structure) but with a new id.

dag(i::Index)

Copy an index i and reverse its direction.

removeqns(::Index)

Removes the QNs from the Index, if it has any.

Iterating over Index I gives the IndexVals I(1) through I(dim(I)).