diff --git a/docs/src/lib/lib.md b/docs/src/lib/lib.md index 0981843f..8793750f 100644 --- a/docs/src/lib/lib.md +++ b/docs/src/lib/lib.md @@ -10,10 +10,15 @@ MPSMultiline ## Operators ```@docs +AbstractMPO +MPO FiniteMPO +InfiniteMPO +MPOHamiltonian +FiniteMPOHamiltonian +InfiniteMPOHamiltonian SparseMPO DenseMPO -MPOHamiltonian ``` ## Environments diff --git a/docs/src/man/operators.md b/docs/src/man/operators.md index 7b407c67..129edbd4 100644 --- a/docs/src/man/operators.md +++ b/docs/src/man/operators.md @@ -71,13 +71,13 @@ O_xzx_sum * FiniteMPS(3, ℂ^2, ℂ^4) make sure that the virtual spaces do not increase past the maximal virtual space that is dictated by the requirement of being full-rank tensors. -## MPOHamiltonian +## FiniteMPOHamiltonian We can also represent quantum Hamiltonians in the same form. This is done by converting a sum of local operators into a single MPO operator. The resulting operator has a very specific structure, and is often referred to as a *Jordan block MPO*. -This object can be constructed as an MPO by using the [`MPOHamiltonian`](@ref) constructor, +This object can be constructed as an MPO by using the [`FiniteMPOHamiltonian`](@ref) constructor, which takes two crucial pieces of information: 1. An array of `VectorSpace` objects, which determines the local Hilbert spaces of the @@ -103,16 +103,16 @@ h = 0.5 chain = fill(ℂ^2, 3) # a finite chain of 4 sites, each with a 2-dimensional Hilbert space single_site_operators = [1 => -h * S_z, 2 => -h * S_z, 3 => -h * S_z] two_site_operators = [(1, 2) => -J * S_x ⊗ S_x, (2, 3) => -J * S_x ⊗ S_x] -H_ising = MPOHamiltonian(chain, single_site_operators..., two_site_operators...); +H_ising = FIniteMPOHamiltonian(chain, single_site_operators..., two_site_operators...); ``` Various alternative constructions are possible, such as using a `Dict` with key-value pairs that specify the operators, or using generator expressions to simplify the construction. ```@example operators -H_ising′ = -J * MPOHamiltonian(chain, +H_ising′ = -J * FiniteMPOHamiltonian(chain, (i, i + 1) => S_x ⊗ S_x for i in 1:(length(chain) - 1)) - - h * MPOHamiltonian(chain, i => S_z for i in 1:length(chain)) + h * FiniteMPOHamiltonian(chain, i => S_z for i in 1:length(chain)) isapprox(H_ising, H_ising′; atol=1e-6) ``` @@ -147,9 +147,9 @@ for I in eachindex(IndexCartesian(), square) end end -H_ising_2d = MPOHamiltonian(square, local_operators) + - MPOHamiltonian(square, horizontal_operators) + - MPOHamiltonian(square, vertical_operators); +H_ising_2d = FiniteMPOHamiltonian(square, local_operators) + + FiniteMPOHamiltonian(square, horizontal_operators) + + FiniteMPOHamiltonian(square, vertical_operators); ``` There are various utility functions available for constructing more advanced lattices, for @@ -224,7 +224,7 @@ Vᵣ = [0, 0, 1] expand(Vₗ * prod(Ws) * Vᵣ) ``` -The `MPOHamiltonian` constructor can also be used to construct the operator from this most +The `FiniteMPOHamiltonian` constructor can also be used to construct the operator from this most general form, by supplying a 3-dimensional array $W$ to the constructor. Here, the first dimension specifies the site in the unit cell, the second dimension specifies the row of the matrix, and the third dimension specifies the column of the matrix. @@ -237,7 +237,7 @@ data[1, 1, 2] = -J * S_x data[1, 2, 3] = S_x data[1, 1, 3] = -h * S_z data_range = repeat(data, 4, 1, 1) # make 4 sites long -H_ising″ = MPOHamiltonian(data_range) +H_ising″ = FiniteMPOHamiltonian(data_range) ``` MPSKit will then automatically attach the correct boundary vectors to the Hamiltonian whenever this is required. @@ -255,7 +255,7 @@ MPSKit will then automatically attach the correct boundary vectors to the Hamilt !!! warning This part is still a work in progress -Because of the discussion above, the `MPOHamiltonian` object is in fact just a `FiniteMPO`, +Because of the discussion above, the `FiniteMPOHamiltonian` object is in fact just an `AbstractMPO`, with some additional structure. This means that similar operations and properties are available, such as the virtual spaces, or the individual tensors. However, the block structure of the operator means that now the virtual spaces are not just a single space, but diff --git a/docs/src/man/states.md b/docs/src/man/states.md index 3c2f7132..060dd5fe 100644 --- a/docs/src/man/states.md +++ b/docs/src/man/states.md @@ -12,16 +12,16 @@ A FiniteMPS is - at its core - a chain of mps tensors. A [`FiniteMPS`](@ref) can be created by passing in a vector of tensormaps: ```julia -data = fill(TensorMap(rand,ComplexF64,ℂ^1*ℂ^2,ℂ^1),10); -FiniteMPS(data); +L = 10 +data = [rand(ComplexF64, ℂ^1 ⊗ ℂ^2 ← ℂ^1) for _ in 1:L]; +FiniteMPS(data) ``` -Or alternatively by +Or alternatively by specifying its structure ```julia -len = 10; -max_bond_dimension = ℂ^10; -physical_space = ℂ^2; -FiniteMPS(rand,ComplexF64,len,physical_space,max_bond_dimension); +max_bond_dimension = ℂ^10 +physical_space = ℂ^2 +FiniteMPS(rand, ComplexF64, L, physical_space, max_bond_dimension) ``` You can take dot products, renormalize!, expectation values,.... @@ -43,7 +43,8 @@ then the state will be gauged such that the third tensor is a left isometry (sim ```julia state.AC[3] ``` -gauges the state in such a way that all tensors to the left are left isometries, and to the right will be right isometries.As a result you should have +gauges the state in such a way that all tensors to the left are left isometries, and to the right will be right isometries. +As a result you should have ```julia norm(state) == norm(state.AC[3]) @@ -68,12 +69,14 @@ ACs::Vector{Union{Missing,A}} CLs::Vector{Union{Missing,B}} ``` -calling state.AC returns an "orthoview" instance, which is a very simple dummy object. When you call get/setindex on an orthoview, it will move the gauge for the underlying state, and return the result. The idea behind this construction is that one never has to worry about how the state is gauged, as this gets handled automagically. +calling `state.AC` returns an "orthoview" instance, which is a very simple dummy object. +When you call get/setindex on an orthoview, it will move the gauge for the underlying state, and return the result. +The idea behind this construction is that one never has to worry about how the state is gauged, as this gets handled automagically. The following bit of code shows the logic in action: ```julia -state = FiniteMPS(10,ℂ^2,ℂ^10); # a random initial state +state = FiniteMPS(10, ℂ^2, ℂ^10); # a random initial state @show ismissing.(state.ALs) # all AL fields are already calculated @show ismissing.(state.ARs) # all AR fields are missing