diff --git a/README.md b/README.md index 4eaabcaa1..215b4145a 100644 --- a/README.md +++ b/README.md @@ -63,7 +63,7 @@ with MPSKit. For example, to install the package with support for SU(N) symmetri pkg> add TensorKit ``` -Finally, several pre-defined operators, hamiltonians and statistical mechanics models are available in [MPSKitModels.jl](https://github.com/QuantumKitHub/MPSKitModels.jl). It is recommended to install this package too. +Finally, several pre-defined operators, Hamiltonians and statistical mechanics models are available in [MPSKitModels.jl](https://github.com/QuantumKitHub/MPSKitModels.jl). It is recommended to install this package too. ```julia-repl pkg> add MPSKitModels @@ -72,7 +72,7 @@ pkg> add MPSKitModels ## Quickstart After following the installation process, it should now be possible to load the packages and -start simulating. For example, to obtain the groundstate of the 1D Ising model, we can use +start simulating. For example, to obtain the ground state of the 1D Ising model, we can use the following code: ```julia diff --git a/docs/src/examples/quantum1d/1.ising-cft/index.md b/docs/src/examples/quantum1d/1.ising-cft/index.md index 647943ce2..d69b6d38f 100644 --- a/docs/src/examples/quantum1d/1.ising-cft/index.md +++ b/docs/src/examples/quantum1d/1.ising-cft/index.md @@ -17,7 +17,7 @@ using MPSKit, MPSKitModels, TensorKit, Plots, KrylovKit using LinearAlgebra: eigvals, diagm, Hermitian ```` -The hamiltonian is defined on a finite lattice with periodic boundary conditions, +The Hamiltonian is defined on a finite lattice with periodic boundary conditions, which can be implemented as follows: ````julia @@ -45,8 +45,8 @@ H = periodic_boundary_conditions(transverse_field_ising(), L) ## Exact diagonalisation In MPSKit, there is support for exact diagonalisation by leveraging the fact that applying -the hamiltonian to an untruncated MPS will result in an effective hamiltonian on the center -site which implements the action of the entire hamiltonian. Thus, optimizing the middle +the Hamiltonian to an untruncated MPS will result in an effective Hamiltonian on the center +site which implements the action of the entire Hamiltonian. Thus, optimizing the middle tensor is equivalent to optimixing a state in the entire Hilbert space, as all other tensors are just unitary matrices that mix the basis. @@ -90,7 +90,7 @@ end O_shift (generic function with 1 method) ```` -We can then calculate the momentum of the groundstate as the expectation value of this +We can then calculate the momentum of the ground state as the expectation value of this operator. However, there is a subtlety because of the degeneracies in the energy eigenvalues. The eigensolver will find an orthonormal basis within each energy subspace, but this basis is not necessarily a basis of eigenstates of the translation operator. In order @@ -225,7 +225,7 @@ D = 64 ```` -Excitations on top of the groundstate can be found through the use of the quasiparticle +Excitations on top of the ground state can be found through the use of the quasiparticle ansatz. This returns quasiparticle states, which can be converted to regular `FiniteMPS` objects. diff --git a/docs/src/examples/quantum1d/2.haldane/index.md b/docs/src/examples/quantum1d/2.haldane/index.md index 6facc6123..3b3195e15 100644 --- a/docs/src/examples/quantum1d/2.haldane/index.md +++ b/docs/src/examples/quantum1d/2.haldane/index.md @@ -15,13 +15,13 @@ To follow the tutorial you need the following packages: using MPSKit, MPSKitModels, TensorKit, Plots, Polynomials ```` -The Heisenberg model is defined by the following hamiltonian: +The Heisenberg model is defined by the following Hamiltonian: ```math H = -J∑_{⟨i,j⟩} (X_i X_j + Y_i Y_j + Z_i Z_j) ``` -This hamiltonian has an SU(2) symmetry, which we can enforce by using SU(2)-symmetric tensors: +This Hamiltonian has an SU(2) symmetry, which we can enforce by using SU(2)-symmetric tensors: ````julia symmetry = SU2Irrep @@ -36,7 +36,7 @@ J = 1 ## Finite size extrapolation We can start the analysis using finite-size methods. -The groundstate of this model can be approximated using finite MPS through the use of DMRG. +The ground state of this model can be approximated using finite MPS through the use of DMRG. The typical way to find excited states is to minimize the energy while adding an error term $$λ \left|gs\right> \left< gs\right|$$ @@ -120,7 +120,7 @@ plot!(p_size_extrapolation, x -> f(x); label = "fit") A much nicer way of obtaining the Haldane gap is by working directly in the thermodynamic limit. As was already hinted at by the edge modes, this model is in a non-trivial SPT phase. Thus, care must be taken when selecting the symmetry sectors. -The groundstate has half-integer edge modes, thus the virtual spaces must also all carry half-integer charges. +The ground state has half-integer edge modes, thus the virtual spaces must also all carry half-integer charges. In contrast with the finite size case, we now should specify a momentum label to the excitations. This way, it is possible to scan the dispersion relation over the entire momentum space. diff --git a/docs/src/examples/quantum1d/3.ising-dqpt/index.md b/docs/src/examples/quantum1d/3.ising-dqpt/index.md index 60b79922e..85b5468bc 100644 --- a/docs/src/examples/quantum1d/3.ising-dqpt/index.md +++ b/docs/src/examples/quantum1d/3.ising-dqpt/index.md @@ -15,10 +15,10 @@ In this tutorial we will try to reproduce the results from using MPSKit, MPSKitModels, TensorKit ```` -Dynamical quantum phase transitions (DQPT in short) are signatures of equilibrium phase transitions in a dynamical quantity - the loschmidth echo. +Dynamical quantum phase transitions (DQPT in short) are signatures of equilibrium phase transitions in a dynamical quantity - the Loschmidt echo. This quantity is given by ``L(t) = \frac{-2}{N} ln(| < \psi(t) | \psi(0) > |) `` where ``N`` is the system size. -One typically starts from a groundstate and then quenches the hamiltonian to a different point. -Non analycities in the loschmidth echo are called 'dynamical quantum phase transitions'. +One typically starts from a ground state and then quenches the Hamiltonian to a different point. +Non analycities in the Loschmidt echo are called 'dynamical quantum phase transitions'. In the mentioned paper they work with @@ -27,9 +27,9 @@ In the mentioned paper they work with and show that divergences occur when quenching across the critical point (g₀ → g₁) for ``t^*_n = t^*(n+\frac{1}{2})`` with ``t^* = \pi/e(g_1,k^*)``, ``cos(k^*) = (1+g_0 g_1) / (g_0 + g_1)``, `` e(g,k) = \sqrt{(g-cos k)^2 + sin^2 k}``. The outline of the tutorial is as follows. We will pick ``g₀ = 0.5``, ``g₁ = 2.0``, and perform the time evolution at different system sizes and compare with the thermodynamic limit. -For those ``g`` we expect non-analicities to occur at ``t_n ≈ 2.35 (n + 1/2)``. +For those ``g`` we expect non-analyticities to occur at ``t_n ≈ 2.35 (n + 1/2)``. -First we construct the hamiltonian in mpo form, and obtain the pre-quenched groundstate: +First we construct the Hamiltonian in MPO form, and obtain the pre-quenched ground state: ````julia L = 20 @@ -67,7 +67,7 @@ dt = 0.01 ψₜ, envs = timestep(ψₜ, H₁, 0, dt, TDVP2(; trscheme = truncrank(20))); ```` -"envs" is a kind of cache object that keeps track of all environments in `ψ`. It is often advantageous to re-use the environment, so that mpskit doesn't need to recalculate everything. +"envs" is a kind of cache object that keeps track of all environments in `ψ`. It is often advantageous to re-use the environment, so that MPSKit doesn't need to recalculate everything. Putting it all together, we get @@ -102,7 +102,7 @@ finite_sim (generic function with 1 method) ## Infinite MPS quenching -Similarly we could start with an initial infinite state and find the pre-quench groundstate: +Similarly we could start with an initial infinite state and find the pre-quench ground state: ````julia ψ₀ = InfiniteMPS([ℂ^2], [ℂ^10]) @@ -133,16 +133,15 @@ dot(ψ₀, ψ₀) 1.000000000000001 - 2.1950801504054652e-16im ```` -so the loschmidth echo takes on the pleasant form +so the Loschmidt echo takes on the pleasant form ````julia echo(ψ₀::InfiniteMPS, ψₜ::InfiniteMPS) = -2 * log(abs(dot(ψ₀, ψₜ))) @assert isapprox(echo(ψ₀, ψ₀), 0, atol = 1.0e-10) ```` -This time we cannot use a two-site scheme to grow the bond dimension, as this isn't implemented (yet). -Instead, we have to make use of the changebonds machinery. -Multiple algorithms are available, but we will only focus on `OptimalEpand()`. +We make use of the `changebonds` machinery to grow the bond dimension. This can also be achieved through a two-site scheme. +Multiple algorithms are available, but we will only focus on `OptimalExpand()`. Growing the bond dimension by ``5`` can be done by calling: ````julia diff --git a/docs/src/examples/quantum1d/3.ising-dqpt/main.ipynb b/docs/src/examples/quantum1d/3.ising-dqpt/main.ipynb index 03f23362a..b0e82357c 100644 --- a/docs/src/examples/quantum1d/3.ising-dqpt/main.ipynb +++ b/docs/src/examples/quantum1d/3.ising-dqpt/main.ipynb @@ -22,10 +22,10 @@ { "cell_type": "markdown", "source": [ - "Dynamical quantum phase transitions (DQPT in short) are signatures of equilibrium phase transitions in a dynamical quantity - the loschmidth echo.\n", + "Dynamical quantum phase transitions (DQPT in short) are signatures of equilibrium phase transitions in a dynamical quantity - the Loschmidt echo.\n", "This quantity is given by $L(t) = \\frac{-2}{N} ln(| < \\psi(t) | \\psi(0) > |) $ where $N$ is the system size.\n", "One typically starts from a groundstate and then quenches the hamiltonian to a different point.\n", - "Non analycities in the loschmidth echo are called 'dynamical quantum phase transitions'.\n", + "Non analycities in the Loschmidt echo are called 'dynamical quantum phase transitions'.\n", "\n", "In the mentioned paper they work with\n", "\n", @@ -34,7 +34,7 @@ "and show that divergences occur when quenching across the critical point (g₀ → g₁) for $t^*_n = t^*(n+\\frac{1}{2})$ with $t^* = \\pi/e(g_1,k^*)$, $cos(k^*) = (1+g_0 g_1) / (g_0 + g_1)$, $ e(g,k) = \\sqrt{(g-cos k)^2 + sin^2 k}$.\n", "\n", "The outline of the tutorial is as follows. We will pick $g₀ = 0.5$, $g₁ = 2.0$, and perform the time evolution at different system sizes and compare with the thermodynamic limit.\n", - "For those $g$ we expect non-analicities to occur at $t_n ≈ 2.35 (n + 1/2)$.\n", + "For those $g$ we expect non-analyticities to occur at $t_n ≈ 2.35 (n + 1/2)$.\n", "\n", "First we construct the hamiltonian in mpo form, and obtain the pre-quenched groundstate:" ], @@ -174,7 +174,7 @@ { "cell_type": "markdown", "source": [ - "so the loschmidth echo takes on the pleasant form" + "so the Loschmidt echo takes on the pleasant form" ], "metadata": {} }, diff --git a/docs/src/examples/quantum1d/4.xxz-heisenberg/index.md b/docs/src/examples/quantum1d/4.xxz-heisenberg/index.md index 712b6b3ef..33c25c263 100644 --- a/docs/src/examples/quantum1d/4.xxz-heisenberg/index.md +++ b/docs/src/examples/quantum1d/4.xxz-heisenberg/index.md @@ -17,7 +17,7 @@ using MPSKit, MPSKitModels, TensorKit, Plots ## Failure -First we should define the hamiltonian we want to work with. +First we should define the Hamiltonian we want to work with. Then we specify an initial guess, which we then further optimize. Working directly in the thermodynamic limit, this is achieved as follows: @@ -33,7 +33,7 @@ single site InfiniteMPOHamiltonian{MPSKit.JordanMPOTensor{ComplexF64, TensorKit. ```` -We then need an intial state, which we shall later optimize. In this example we work directly in the thermodynamic limit. +We then need an initial state, which we shall later optimize. In this example we work directly in the thermodynamic limit. ````julia state = InfiniteMPS(2, 20) @@ -48,7 +48,7 @@ single site InfiniteMPS: ```` -The groundstate can then be found by calling `find_groundstate`. +The ground state can then be found by calling `find_groundstate`. ````julia groundstate, cache, delta = find_groundstate(state, H, VUMPS()); @@ -261,7 +261,7 @@ groundstate, cache, delta = find_groundstate(state, H, VUMPS()); ```` As you can see, VUMPS struggles to converge. -On it's own, that is already quite curious. +On its own, that is already quite curious. Maybe we can do better using another algorithm, such as gradient descent. ````julia @@ -309,9 +309,9 @@ state = InfiniteMPS(fill(2, 2), fill(20, 2)) ```` -In MPSKit, we require that the periodicity of the hamiltonian equals that of the state it is applied to. -This is not a big obstacle, you can simply repeat the original hamiltonian. -Alternatively, the hamiltonian can be constructed directly on a two-site unitcell by making use of MPSKitModels.jl's `@mpoham`. +In MPSKit, we require that the periodicity of the Hamiltonian equals that of the state it is applied to. +This is not a big obstacle, you can simply repeat the original Hamiltonian. +Alternatively, the Hamiltonian can be constructed directly on a two-site unit cell by making use of MPSKitModels.jl's `@mpoham`. ````julia # H2 = repeat(H, 2); -- copies the one-site version @@ -450,9 +450,9 @@ It are precisely those problems that we can solve by using symmetries. ## Symmetries -The XXZ Heisenberg hamiltonian is SU(2) symmetric and we can exploit this to greatly speed up the simulation. +The XXZ Heisenberg Hamiltonian is SU(2) symmetric and we can exploit this to greatly speed up the simulation. -It is cumbersome to construct symmetric hamiltonians, but luckily su(2) symmetric XXZ is already implemented: +It is cumbersome to construct symmetric Hamiltonians, but luckily SU(2) symmetric XXZ is already implemented: ````julia H2 = heisenberg_XXX(ComplexF64, SU2Irrep, InfiniteChain(2); spin = 1 // 2); diff --git a/docs/src/examples/quantum1d/5.haldane-spt/index.md b/docs/src/examples/quantum1d/5.haldane-spt/index.md index abd4f7a80..cb5eeef18 100644 --- a/docs/src/examples/quantum1d/5.haldane-spt/index.md +++ b/docs/src/examples/quantum1d/5.haldane-spt/index.md @@ -105,8 +105,8 @@ transferplot(ψ; sectors, title = "Transfer matrix spectrum", legend = :outertop ``` Nevertheless, using the symmetry, this can be remedied rather easily, by imposing the -groundstate to belong to a single class, and comparing the results. We can readily obtain 3 -different criteria for determining the SPT phase of the groundstate. +ground state to belong to a single class, and comparing the results. We can readily obtain 3 +different criteria for determining the SPT phase of the ground state. Firstly, we can compare variational energies for states of similar bond dimensions. As we expect the state of the wrong SPT phase to have to expend some of its expressiveness in @@ -168,19 +168,19 @@ plot(entanglementp_plus, entanglementp_minus; layout = (1, 2), size = (800, 400) ``` -As we can see, the groundstate can be found in the non-trivial SPT phase, $\ket{\psi_-}$. We +As we can see, the ground state can be found in the non-trivial SPT phase, $\ket{\psi_-}$. We can obtain an intuitive understanding of $\ket{\psi_+}$ by considering the following -diagram. If we denote the MPS tensors that make up the groundstate as $A_-$, we can -construct a state in the trivial SPT phase that approximates the groundstate as follows: +diagram. If we denote the MPS tensors that make up the ground state as $A_-$, we can +construct a state in the trivial SPT phase that approximates the ground state as follows: ```@raw html SPT tensors ``` In other words, we can factorize a purely virtual isomorphism of $S = 1/2$ in order to -obtain the groundstate. This then also explains the degeneracies in the entanglement +obtain the ground state. This then also explains the degeneracies in the entanglement spectrum as well as in the transfer matrix spectrum. Finally, we can further confirm this -intuition by looking at the entanglement entropy of the groundstate. As we can see, the +intuition by looking at the entanglement entropy of the ground state. As we can see, the entanglement entropy of the state in the wrong SPT phase is exactly $log(2)$ higher than the one in the right SPT phase, which is exactly what we would expect from the diagram above. diff --git a/docs/src/examples/quantum1d/6.hubbard/index.md b/docs/src/examples/quantum1d/6.hubbard/index.md index a012ed02b..f032b7506 100644 --- a/docs/src/examples/quantum1d/6.hubbard/index.md +++ b/docs/src/examples/quantum1d/6.hubbard/index.md @@ -54,7 +54,7 @@ const U = 3.0 3.0 ```` -For this case, the groundstate energy has an analytic solution, which can be used to benchmark the numerical results. +For this case, the ground state energy has an analytic solution, which can be used to benchmark the numerical results. It follows from Eq. (6.82) in [](). ```math diff --git a/docs/src/index.md b/docs/src/index.md index 18c8c5813..48b4c30a1 100644 --- a/docs/src/index.md +++ b/docs/src/index.md @@ -100,7 +100,7 @@ println(" = $N2") ``` Finally, the MPS can be optimized in order to determine groundstates of given Hamiltonians. -Using the pre-defined models in `MPSKitModels`, we can construct the groundstate for the +Using the pre-defined models in `MPSKitModels`, we can construct the ground state for the transverse field Ising model: ```@example finitemps @@ -177,7 +177,7 @@ println(" = $N2") Finally, the MPS can be optimized in order to determine groundstates of given Hamiltonians. There are plenty of pre-defined models in `MPSKitModels`, but we can also manually construct -the groundstate for the transverse field Ising model: +the ground state for the transverse field Ising model: ```@example infinitemps J = 1.0 diff --git a/docs/src/man/algorithms.md b/docs/src/man/algorithms.md index 94698b9d5..3cf71d52a 100644 --- a/docs/src/man/algorithms.md +++ b/docs/src/man/algorithms.md @@ -9,7 +9,7 @@ If a particular algorithm is missing, feel free to let us know via an issue, or ## Groundstates -One of the most prominent use-cases of MPS is to obtain the groundstate of a given (quasi-) one-dimensional quantum Hamiltonian. +One of the most prominent use-cases of MPS is to obtain the ground state of a given (quasi-) one-dimensional quantum Hamiltonian. In MPSKit.jl, this can be achieved through `find_groundstate`: ```@docs; canonical=false @@ -58,7 +58,7 @@ IDMRG2 ### VUMPS -[`VUMPS`](@ref) is an (I)DMRG inspired algorithm that can be used to variationally find the groundstate as a Uniform (infinite) Matrix Product State. +[`VUMPS`](@ref) is an (I)DMRG inspired algorithm that can be used to variationally find the ground state as a Uniform (infinite) Matrix Product State. In particular, a local update is followed by a re-gauging procedure that effectively replaces the entire network with the newly updated tensor. Compared to IDMRG, this often achieves a higher rate of convergence, since updates are felt throughout the system immediately. Nevertheless, this algorithm only works whenever the state is injective, i.e. there is a unique ground state. @@ -206,7 +206,7 @@ QuasiparticleAnsatz ### Finite excitations -For finite systems we can also do something else - find the groundstate of the hamiltonian + +For finite systems we can also do something else - find the ground state of the Hamiltonian + ``\\text{weight} \sum_i | \\psi_i ⟩ ⟨ \\psi_i ``. This is also supported by calling ```@example excitations @@ -358,8 +358,8 @@ Jeckelmann ### fidelity susceptibility -The fidelity susceptibility measures how much the groundstate changes when tuning a -parameter in your hamiltonian. Divergences occur at phase transitions, making it a valuable +The fidelity susceptibility measures how much the ground state changes when tuning a +parameter in your Hamiltonian. Divergences occur at phase transitions, making it a valuable measure when no order parameter is known. ```@docs; canonical=false diff --git a/docs/src/man/environments.md b/docs/src/man/environments.md index 0b8d9b42f..dbe00ad25 100644 --- a/docs/src/man/environments.md +++ b/docs/src/man/environments.md @@ -1,8 +1,8 @@ # [Environments](@id um_environments) In many tensor network algorithms we encounter partially contracted tensor networks. -In DMRG for example, one needs to know the sum of all the hamiltonian contributions left and right of the site that we want to optimize. -If you then optimize the neighboring site to the right, you only need to add one new contribution to the previous sum of hamiltonian contributions. +In DMRG for example, one needs to know the sum of all the Hamiltonian contributions left and right of the site that we want to optimize. +If you then optimize the neighboring site to the right, you only need to add one new contribution to the previous sum of Hamiltonian contributions. This kind of information is stored in the environment objects. The goal is that the user should preferably never have to deal with these objects, but being aware of the inner workings may allow you to write more efficient code. @@ -10,7 +10,7 @@ That is why they are nonetheless included in the manual. ## Finite Environments -When you create a state and a hamiltonian: +When you create a state and a Hamiltonian: ```julia state = FiniteMPS(rand, ComplexF64, 20, ℂ^2, ℂ^10); diff --git a/docs/src/man/intro.md b/docs/src/man/intro.md index e0bb7a998..48204a5b4 100644 --- a/docs/src/man/intro.md +++ b/docs/src/man/intro.md @@ -81,7 +81,7 @@ follows: ``` Finally, the definition of a MPO tensor, which is used to represent statistical mechanics -problems as well as quantum hamiltonians, is represented as: +problems as well as quantum Hamiltonians, is represented as: ```@raw html convention MPOTensor diff --git a/examples/quantum1d/1.ising-cft/main.jl b/examples/quantum1d/1.ising-cft/main.jl index ff3d38c5d..c473b59b1 100644 --- a/examples/quantum1d/1.ising-cft/main.jl +++ b/examples/quantum1d/1.ising-cft/main.jl @@ -10,7 +10,7 @@ using MPSKit, MPSKitModels, TensorKit, Plots, KrylovKit using LinearAlgebra: eigvals, diagm, Hermitian md""" -The hamiltonian is defined on a finite lattice with periodic boundary conditions, +The Hamiltonian is defined on a finite lattice with periodic boundary conditions, which can be implemented as follows: """ @@ -21,8 +21,8 @@ md""" ## Exact diagonalisation In MPSKit, there is support for exact diagonalisation by leveraging the fact that applying -the hamiltonian to an untruncated MPS will result in an effective hamiltonian on the center -site which implements the action of the entire hamiltonian. Thus, optimizing the middle +the Hamiltonian to an untruncated MPS will result in an effective Hamiltonian on the center +site which implements the action of the entire Hamiltonian. Thus, optimizing the middle tensor is equivalent to optimixing a state in the entire Hilbert space, as all other tensors are just unitary matrices that mix the basis. """ @@ -60,7 +60,7 @@ function O_shift(L) end md""" -We can then calculate the momentum of the groundstate as the expectation value of this +We can then calculate the momentum of the ground state as the expectation value of this operator. However, there is a subtlety because of the degeneracies in the energy eigenvalues. The eigensolver will find an orthonormal basis within each energy subspace, but this basis is not necessarily a basis of eigenstates of the translation operator. In order @@ -125,7 +125,7 @@ D = 64 ψ, envs, δ = find_groundstate(FiniteMPS(L_mps, ℂ^2, ℂ^D), H_mps, DMRG()); md""" -Excitations on top of the groundstate can be found through the use of the quasiparticle +Excitations on top of the ground state can be found through the use of the quasiparticle ansatz. This returns quasiparticle states, which can be converted to regular `FiniteMPS` objects. """ diff --git a/examples/quantum1d/2.haldane/main.jl b/examples/quantum1d/2.haldane/main.jl index 4982e12cd..37e16ba90 100644 --- a/examples/quantum1d/2.haldane/main.jl +++ b/examples/quantum1d/2.haldane/main.jl @@ -8,13 +8,13 @@ To follow the tutorial you need the following packages: using MPSKit, MPSKitModels, TensorKit, Plots, Polynomials md""" -The Heisenberg model is defined by the following hamiltonian: +The Heisenberg model is defined by the following Hamiltonian: ```math H = -J∑_{⟨i,j⟩} (X_i X_j + Y_i Y_j + Z_i Z_j) ``` -This hamiltonian has an SU(2) symmetry, which we can enforce by using SU(2)-symmetric tensors: +This Hamiltonian has an SU(2) symmetry, which we can enforce by using SU(2)-symmetric tensors: """ symmetry = SU2Irrep @@ -25,7 +25,7 @@ md""" ## Finite size extrapolation We can start the analysis using finite-size methods. -The groundstate of this model can be approximated using finite MPS through the use of DMRG. +The ground state of this model can be approximated using finite MPS through the use of DMRG. The typical way to find excited states is to minimize the energy while adding an error term $$λ \left|gs\right> \left< gs\right|$$ @@ -93,7 +93,7 @@ md""" A much nicer way of obtaining the Haldane gap is by working directly in the thermodynamic limit. As was already hinted at by the edge modes, this model is in a non-trivial SPT phase. Thus, care must be taken when selecting the symmetry sectors. -The groundstate has half-integer edge modes, thus the virtual spaces must also all carry half-integer charges. +The ground state has half-integer edge modes, thus the virtual spaces must also all carry half-integer charges. In contrast with the finite size case, we now should specify a momentum label to the excitations. This way, it is possible to scan the dispersion relation over the entire momentum space. diff --git a/examples/quantum1d/3.ising-dqpt/main.jl b/examples/quantum1d/3.ising-dqpt/main.jl index 678be6c29..b9232ae00 100644 --- a/examples/quantum1d/3.ising-dqpt/main.jl +++ b/examples/quantum1d/3.ising-dqpt/main.jl @@ -8,10 +8,10 @@ In this tutorial we will try to reproduce the results from using MPSKit, MPSKitModels, TensorKit md""" -Dynamical quantum phase transitions (DQPT in short) are signatures of equilibrium phase transitions in a dynamical quantity - the loschmidth echo. +Dynamical quantum phase transitions (DQPT in short) are signatures of equilibrium phase transitions in a dynamical quantity - the Loschmidt echo. This quantity is given by ``L(t) = \frac{-2}{N} ln(| < \psi(t) | \psi(0) > |) `` where ``N`` is the system size. -One typically starts from a groundstate and then quenches the hamiltonian to a different point. -Non analycities in the loschmidth echo are called 'dynamical quantum phase transitions'. +One typically starts from a ground state and then quenches the Hamiltonian to a different point. +Non analycities in the Loschmidt echo are called 'dynamical quantum phase transitions'. In the mentioned paper they work with @@ -20,9 +20,9 @@ In the mentioned paper they work with and show that divergences occur when quenching across the critical point (g₀ → g₁) for ``t^*_n = t^*(n+\frac{1}{2})`` with ``t^* = \pi/e(g_1,k^*)``, ``cos(k^*) = (1+g_0 g_1) / (g_0 + g_1)``, `` e(g,k) = \sqrt{(g-cos k)^2 + sin^2 k}``. The outline of the tutorial is as follows. We will pick ``g₀ = 0.5``, ``g₁ = 2.0``, and perform the time evolution at different system sizes and compare with the thermodynamic limit. -For those ``g`` we expect non-analicities to occur at ``t_n ≈ 2.35 (n + 1/2)``. +For those ``g`` we expect non-analyticities to occur at ``t_n ≈ 2.35 (n + 1/2)``. -First we construct the hamiltonian in mpo form, and obtain the pre-quenched groundstate: +First we construct the Hamiltonian in MPO form, and obtain the pre-quenched ground state: """ L = 20 @@ -49,7 +49,7 @@ dt = 0.01 ψₜ, envs = timestep(ψₜ, H₁, 0, dt, TDVP2(; trscheme = truncrank(20))); md""" -"envs" is a kind of cache object that keeps track of all environments in `ψ`. It is often advantageous to re-use the environment, so that mpskit doesn't need to recalculate everything. +"envs" is a kind of cache object that keeps track of all environments in `ψ`. It is often advantageous to re-use the environment, so that MPSKit doesn't need to recalculate everything. Putting it all together, we get """ @@ -80,7 +80,7 @@ end md""" ## Infinite MPS quenching -Similarly we could start with an initial infinite state and find the pre-quench groundstate: +Similarly we could start with an initial infinite state and find the pre-quench ground state: """ ψ₀ = InfiniteMPS([ℂ^2], [ℂ^10]) @@ -95,16 +95,15 @@ It is this ``α`` that is returned when calling dot(ψ₀, ψ₀) md""" -so the loschmidth echo takes on the pleasant form +so the Loschmidt echo takes on the pleasant form """ echo(ψ₀::InfiniteMPS, ψₜ::InfiniteMPS) = -2 * log(abs(dot(ψ₀, ψₜ))) @assert isapprox(echo(ψ₀, ψ₀), 0, atol = 1.0e-10) md""" -This time we cannot use a two-site scheme to grow the bond dimension, as this isn't implemented (yet). -Instead, we have to make use of the changebonds machinery. -Multiple algorithms are available, but we will only focus on `OptimalEpand()`. +We make use of the `changebonds` machinery to grow the bond dimension. This can also be achieved through a two-site scheme. +Multiple algorithms are available, but we will only focus on `OptimalExpand()`. Growing the bond dimension by ``5`` can be done by calling: """ diff --git a/examples/quantum1d/4.xxz-heisenberg/main.jl b/examples/quantum1d/4.xxz-heisenberg/main.jl index 93fe3235c..52930bdc0 100644 --- a/examples/quantum1d/4.xxz-heisenberg/main.jl +++ b/examples/quantum1d/4.xxz-heisenberg/main.jl @@ -10,7 +10,7 @@ using MPSKit, MPSKitModels, TensorKit, Plots md""" ## Failure -First we should define the hamiltonian we want to work with. +First we should define the Hamiltonian we want to work with. Then we specify an initial guess, which we then further optimize. Working directly in the thermodynamic limit, this is achieved as follows: """ @@ -18,20 +18,20 @@ Working directly in the thermodynamic limit, this is achieved as follows: H = heisenberg_XXX(; spin = 1 // 2) md""" -We then need an intial state, which we shall later optimize. In this example we work directly in the thermodynamic limit. +We then need an initial state, which we shall later optimize. In this example we work directly in the thermodynamic limit. """ state = InfiniteMPS(2, 20) md""" -The groundstate can then be found by calling `find_groundstate`. +The ground state can then be found by calling `find_groundstate`. """ groundstate, cache, delta = find_groundstate(state, H, VUMPS()); md""" As you can see, VUMPS struggles to converge. -On it's own, that is already quite curious. +On its own, that is already quite curious. Maybe we can do better using another algorithm, such as gradient descent. """ @@ -60,9 +60,9 @@ Let's initialize a different initial state, this time with a 2-site unit cell: state = InfiniteMPS(fill(2, 2), fill(20, 2)) md""" -In MPSKit, we require that the periodicity of the hamiltonian equals that of the state it is applied to. -This is not a big obstacle, you can simply repeat the original hamiltonian. -Alternatively, the hamiltonian can be constructed directly on a two-site unitcell by making use of MPSKitModels.jl's `@mpoham`. +In MPSKit, we require that the periodicity of the Hamiltonian equals that of the state it is applied to. +This is not a big obstacle, you can simply repeat the original Hamiltonian. +Alternatively, the Hamiltonian can be constructed directly on a two-site unit cell by making use of MPSKitModels.jl's `@mpoham`. """ ## H2 = repeat(H, 2); -- copies the one-site version @@ -93,9 +93,9 @@ It are precisely those problems that we can solve by using symmetries. md""" ## Symmetries -The XXZ Heisenberg hamiltonian is SU(2) symmetric and we can exploit this to greatly speed up the simulation. +The XXZ Heisenberg Hamiltonian is SU(2) symmetric and we can exploit this to greatly speed up the simulation. -It is cumbersome to construct symmetric hamiltonians, but luckily su(2) symmetric XXZ is already implemented: +It is cumbersome to construct symmetric Hamiltonians, but luckily SU(2) symmetric XXZ is already implemented: """ H2 = heisenberg_XXX(ComplexF64, SU2Irrep, InfiniteChain(2); spin = 1 // 2); diff --git a/examples/quantum1d/5.haldane-spt/main.jl b/examples/quantum1d/5.haldane-spt/main.jl index ab6f72298..7bccee8e4 100644 --- a/examples/quantum1d/5.haldane-spt/main.jl +++ b/examples/quantum1d/5.haldane-spt/main.jl @@ -86,8 +86,8 @@ transferplot(ψ; sectors, title = "Transfer matrix spectrum", legend = :outertop md""" Nevertheless, using the symmetry, this can be remedied rather easily, by imposing the -groundstate to belong to a single class, and comparing the results. We can readily obtain 3 -different criteria for determining the SPT phase of the groundstate. +ground state to belong to a single class, and comparing the results. We can readily obtain 3 +different criteria for determining the SPT phase of the ground state. Firstly, we can compare variational energies for states of similar bond dimensions. As we expect the state of the wrong SPT phase to have to expend some of its expressiveness in @@ -134,19 +134,19 @@ plot(entanglementp_plus, entanglementp_minus; layout = (1, 2), size = (800, 400) md""" -As we can see, the groundstate can be found in the non-trivial SPT phase, $\ket{\psi_-}$. We +As we can see, the ground state can be found in the non-trivial SPT phase, $\ket{\psi_-}$. We can obtain an intuitive understanding of $\ket{\psi_+}$ by considering the following -diagram. If we denote the MPS tensors that make up the groundstate as $A_-$, we can -construct a state in the trivial SPT phase that approximates the groundstate as follows: +diagram. If we denote the MPS tensors that make up the ground state as $A_-$, we can +construct a state in the trivial SPT phase that approximates the ground state as follows: ```@raw html SPT tensors ``` In other words, we can factorize a purely virtual isomorphism of $S = 1/2$ in order to -obtain the groundstate. This then also explains the degeneracies in the entanglement +obtain the ground state. This then also explains the degeneracies in the entanglement spectrum as well as in the transfer matrix spectrum. Finally, we can further confirm this -intuition by looking at the entanglement entropy of the groundstate. As we can see, the +intuition by looking at the entanglement entropy of the ground state. As we can see, the entanglement entropy of the state in the wrong SPT phase is exactly $log(2)$ higher than the one in the right SPT phase, which is exactly what we would expect from the diagram above. """ diff --git a/examples/quantum1d/6.hubbard/main.jl b/examples/quantum1d/6.hubbard/main.jl index baa7a3bb0..50eabfe8b 100644 --- a/examples/quantum1d/6.hubbard/main.jl +++ b/examples/quantum1d/6.hubbard/main.jl @@ -41,7 +41,7 @@ const mu = 0.0 const U = 3.0 md""" -For this case, the groundstate energy has an analytic solution, which can be used to benchmark the numerical results. +For this case, the ground state energy has an analytic solution, which can be used to benchmark the numerical results. It follows from Eq. (6.82) in [](). ```math diff --git a/examples/windowmps.jl b/examples/windowmps.jl index c8f56e45f..df9226a9e 100644 --- a/examples/windowmps.jl +++ b/examples/windowmps.jl @@ -1,14 +1,14 @@ using MPSKit, MPSKitModels, TensorKit, Plots let - #defining the hamiltonian + #defining the Hamiltonian th = transverse_field_ising(; g = 0.3) sx, sy, sz = σˣ(ComplexF64), σʸ(ComplexF64), σᶻ(ComplexF64) #initilizing a random mps ts = InfiniteMPS([ℂ^2], [ℂ^12]) - #Finding the groundstate + #Finding the ground state ts, envs, _ = find_groundstate(ts, th, VUMPS(; maxiter = 400)) len = 20 diff --git a/src/algorithms/excitation/chepigaansatz.jl b/src/algorithms/excitation/chepigaansatz.jl index e92a618be..2ed707c6f 100644 --- a/src/algorithms/excitation/chepigaansatz.jl +++ b/src/algorithms/excitation/chepigaansatz.jl @@ -49,7 +49,7 @@ function excitations( info.converged < num && @warn "excitation failed to converge: normres = $(info.normres)" - # discard groundstate + # discard ground state popfirst!(Es) popfirst!(ACs) @@ -114,7 +114,7 @@ function excitations( info.converged < num && @warn "excitation failed to converge: normres = $(info.normres)" - # discard groundstate + # discard ground state popfirst!(Es) popfirst!(AC2s) diff --git a/src/algorithms/excitation/excitations.jl b/src/algorithms/excitation/excitations.jl index 2e8855519..eb1247f90 100644 --- a/src/algorithms/excitation/excitations.jl +++ b/src/algorithms/excitation/excitations.jl @@ -10,15 +10,15 @@ excitations(H, algorithm::ChepigaAnsatz2, ψ::FiniteMPS, [envs]; num=1, pos=length(ψ)÷2) -> (energies, states) -Compute the first excited states and their energy gap above a groundstate. +Compute the first excited states and their energy gap above a ground state. # Arguments - `H::AbstractMPO`: operator for which to find the excitations - `algorithm`: optimization algorithm - `ψ::QP`: initial quasiparticle guess - `ψs::NTuple{N, <:FiniteMPS}`: `N` first excited states -- `[left_environments]`: left groundstate environment -- `[right_environments]`: right groundstate environment +- `[left_environments]`: left ground state environment +- `[right_environments]`: right ground state environment # Keywords - `num::Int`: number of excited states to compute diff --git a/src/algorithms/excitation/quasiparticleexcitation.jl b/src/algorithms/excitation/quasiparticleexcitation.jl index 0eb400258..b26d7d5d5 100644 --- a/src/algorithms/excitation/quasiparticleexcitation.jl +++ b/src/algorithms/excitation/quasiparticleexcitation.jl @@ -72,16 +72,16 @@ end [right_ψ::InfiniteMPS], [right_environment]; kwargs...) -Create and optimise infinite quasiparticle states. +Create and optimize infinite quasiparticle states. # Arguments - `H::AbstractMPO`: operator for which to find the excitations - `algorithm::QuasiparticleAnsatz`: optimization algorithm - `momentum::Union{Number, Vector{<:Number}}`: momentum or list of momenta -- `left_ψ::InfiniteMPS`: left groundstate -- `[left_environment]`: left groundstate environment -- `[right_ψ::InfiniteMPS]`: right groundstate -- `[right_environment]`: right groundstate environment +- `left_ψ::InfiniteMPS`: left ground state +- `[left_environment]`: left ground state environment +- `[right_ψ::InfiniteMPS]`: right ground state +- `[right_environment]`: right ground state environment # Keywords - `num::Int`: number of excited states to compute @@ -152,18 +152,18 @@ function excitations( end """ - excitations(H, algorithm::QuasiparticleAnsatz, left_ψ::InfiniteMPS, [left_environment], - [right_ψ::InfiniteMPS], [right_environment]; kwargs...) + excitations(H, algorithm::QuasiparticleAnsatz, left_ψ::FiniteMPS, [left_environment], + [right_ψ::FiniteMPS], [right_environment]; kwargs...) -Create and optimise finite quasiparticle states. +Create and optimize finite quasiparticle states. # Arguments - `H::AbstractMPO`: operator for which to find the excitations - `algorithm::QuasiparticleAnsatz`: optimization algorithm -- `left_ψ::FiniteMPS`: left groundstate -- `[left_environment]`: left groundstate environment -- `[right_ψ::FiniteMPS]`: right groundstate -- `[right_environment]`: right groundstate environment +- `left_ψ::FiniteMPS`: left ground state +- `[left_environment]`: left ground state environment +- `[right_ψ::FiniteMPS]`: right ground state +- `[right_environment]`: right ground state environment # Keywords - `num::Int`: number of excited states to compute diff --git a/src/algorithms/groundstate/find_groundstate.jl b/src/algorithms/groundstate/find_groundstate.jl index 30a5abcfd..375d25f39 100644 --- a/src/algorithms/groundstate/find_groundstate.jl +++ b/src/algorithms/groundstate/find_groundstate.jl @@ -2,12 +2,12 @@ find_groundstate(ψ₀, H, [environments]; kwargs...) -> (ψ, environments, ϵ) find_groundstate(ψ₀, H, algorithm, environments) -> (ψ, environments, ϵ) -Compute the groundstate for Hamiltonian `H` with initial guess `ψ`. If not specified, an +Compute the ground state for Hamiltonian `H` with initial guess `ψ`. If not specified, an optimization algorithm will be attempted based on the supplied keywords. ## Arguments - `ψ₀::AbstractMPS`: initial guess -- `H::AbstractMPO`: operator for which to find the groundstate +- `H::AbstractMPO`: operator for which to find the ground state - `[environments]`: MPS environment manager - `algorithm`: optimization algorithm @@ -17,7 +17,7 @@ optimization algorithm will be attempted based on the supplied keywords. - `verbosity::Int`: display progress information ## Returns -- `ψ::AbstractMPS`: converged groundstate +- `ψ::AbstractMPS`: converged ground state - `environments`: environments corresponding to the converged state - `ϵ::Float64`: final convergence error upon terminating the algorithm """ diff --git a/src/algorithms/toolbox.jl b/src/algorithms/toolbox.jl index d6c68256c..cf5df3a35 100644 --- a/src/algorithms/toolbox.jl +++ b/src/algorithms/toolbox.jl @@ -196,7 +196,7 @@ end """ variance(state, hamiltonian, [envs=environments(state, hamiltonian)]) -Compute the variance of the energy of the state with respect to the hamiltonian. +Compute the variance of the energy of the state with respect to the Hamiltonian. """ function variance end diff --git a/src/operators/mpohamiltonian.jl b/src/operators/mpohamiltonian.jl index aa7c4004e..a1b5c3129 100644 --- a/src/operators/mpohamiltonian.jl +++ b/src/operators/mpohamiltonian.jl @@ -3,7 +3,7 @@ MPOHamiltonian(lattice::AbstractArray{<:VectorSpace}) MPOHamiltonian(x::AbstractArray{<:Any,3}) -MPO representation of a hamiltonian. This is a specific form of an [`AbstractMPO`](@ref), where +MPO representation of a Hamiltonian. This is a specific form of an [`AbstractMPO`](@ref), where all the sites are represented by an upper triangular block matrix of the following form: ```math diff --git a/src/utility/utility.jl b/src/utility/utility.jl index 49cb96648..061f57c26 100644 --- a/src/utility/utility.jl +++ b/src/utility/utility.jl @@ -20,7 +20,7 @@ end _firstspace(t::AbstractTensorMap) = space(t, 1) _lastspace(t::AbstractTensorMap) = space(t, numind(t)) -#given a hamiltonian with unit legs on the side, decompose it using svds to form a "localmpo" +#given a Hamiltonian with unit legs on the side, decompose it using svds to form a "localmpo" function decompose_localmpo( inpmpo::AbstractTensorMap{T, PS, N, N}, trunc = trunctol(; atol = eps(real(T))^(3 / 4)) ) where {T, PS, N} diff --git a/test/algorithms.jl b/test/algorithms.jl index 207857951..1f70605a4 100644 --- a/test/algorithms.jl +++ b/test/algorithms.jl @@ -16,7 +16,7 @@ module TestAlgorithms verbosity_full = 5 verbosity_conv = 1 - @testset "FiniteMPS groundstate" verbose = true begin + @testset "FiniteMPS ground state" verbose = true begin tol = 1.0e-8 g = 4.0 D = 6 @@ -84,7 +84,7 @@ module TestAlgorithms end end - @testset "InfiniteMPS groundstate" verbose = true begin + @testset "InfiniteMPS ground state" verbose = true begin tol = 1.0e-8 g = 4.0 D = 6 @@ -188,7 +188,7 @@ module TestAlgorithms end end - @testset "LazySum FiniteMPS groundstate" verbose = true begin + @testset "LazySum FiniteMPS ground state" verbose = true begin tol = 1.0e-8 D = 15 atol = 1.0e-2 @@ -253,7 +253,7 @@ module TestAlgorithms end end - @testset "LazySum InfiniteMPS groundstate" verbose = true begin + @testset "LazySum InfiniteMPS ground state" verbose = true begin tol = 1.0e-8 D = 16 atol = 1.0e-2