ExpMPOEvolution

Inheritance Diagram

Inheritance diagram of tenpy.algorithms.mpo_evolution.ExpMPOEvolution

Methods

ExpMPOEvolution.__init__(psi, model, options)

Initialize self.

ExpMPOEvolution.calc_U(dt[, order, …])

Calculate self._U_MPO.

ExpMPOEvolution.get_resume_data()

Return necessary data to resume a run() interrupted at a checkpoint.

ExpMPOEvolution.resume_run()

Resume a run that was interrupted.

ExpMPOEvolution.run()

Run the real-time evolution with the W_I/W_II approximation.

ExpMPOEvolution.update(N_steps)

Time evolve by N_steps steps.

Class Attributes and Properties

ExpMPOEvolution.verbose

class tenpy.algorithms.mpo_evolution.ExpMPOEvolution(psi, model, options)[source]

Bases: tenpy.algorithms.algorithm.TimeEvolutionAlgorithm

Time evolution of an MPS using the W_I or W_II approximation for exp(H dt).

[zaletel2015] described a method to obtain MPO approximations \(W_I\) and \(W_{II}\) for the exponential U = exp(i H dt) of an MPO H, implemented in make_U_I() and make_U_II(). This class uses it for real-time evolution.

Parameters
  • psi (MPS) – Initial state to be time evolved. Modified in place.

  • model (MPOModel) – The model representing the Hamiltonian which we want to time evolve psi with.

  • options (dict) – Further optional parameters are described in ExpMPOEvolution.

Options

config ExpMPOEvolution
option summary

approximation

Specifies which approximation is applied. The default 'II' is more precise. [...]

chi_list (from Sweep) in Sweep.reset_stats

By default (``None``) this feature is disabled. [...]

combine (from Sweep) in Sweep

Whether to combine legs into pipes. This combines the virtual and [...]

compression_method (from ApplyMPO) in MPO.apply

Mandatory. [...]

dt (from TimeEvolutionAlgorithm) in TimeEvolutionAlgorithm

Minimal time step by which to evolve.

init_env_data (from Sweep) in DMRGEngine.init_env

Dictionary as returned by ``self.env.get_initialization_data()`` from [...]

lanczos_params (from Sweep) in Sweep

Lanczos parameters as described in :cfg:config:`Lanczos`.

m_temp (from ZipUpApplyMPO) in MPO.apply_zipup

bond dimension will be truncated to `m_temp * chi_max`

N_steps (from TimeEvolutionAlgorithm) in TimeEvolutionAlgorithm

Number of time steps `dt` to evolve by in :meth:`run`. [...]

N_sweeps (from VariationalCompression) in VariationalCompression

Number of sweeps to perform.

order

Order of the algorithm. The total error up to time `t` scales as ``O(t*dt^o [...]

orthogonal_to (from Sweep) in DMRGEngine.init_env

List of other matrix product states to orthogonalize against. [...]

start_env (from Sweep) in DMRGEngine.init_env

Number of sweeps to be performed without optimization to update [...]

start_time (from TimeEvolutionAlgorithm) in TimeEvolutionAlgorithm

Initial value for :attr:`evolved_time`.

start_trunc_err

Initial truncation error for :attr:`trunc_err`

sweep_0 (from Sweep) in Sweep.reset_stats

Number of sweeps that have already been performed.

trunc_params (from ApplyMPO) in MPO.apply

Truncation parameters as described in :cfg:config:`truncation`.

trunc_weight (from ZipUpApplyMPO) in MPO.apply_zipup

reduces cut for Schmidt values to `trunc_weight * svd_min`

option start_trunc_err: TruncationError

Initial truncation error for trunc_err

option approximation: 'I' | 'II'

Specifies which approximation is applied. The default ‘II’ is more precise. See [zaletel2015] and make_U() for more details.

option order: int

Order of the algorithm. The total error up to time t scales as O(t*dt^order). Implemented are order = 1 and order = 2.

options

Optional parameters, see run() for more details

Type

Config

evolved_time

Indicating how long psi has been evolved, psi = exp(-i * evolved_time * H) psi(t=0).

Type

float

trunc_err

The error of the represented state which is introduced due to the truncation during the sequence of update steps

Type

TruncationError

psi

The MPS, time evolved in-place.

Type

MPS

model

The model defining the Hamiltonian.

Type

MPOModel

_U

Exponentiated H_MPO;

Type

list of MPO

_U_param

A dictionary containing the information of the latest created _U. We won’t recalculate _U if those parameters didn’t change.

Type

dict

run()[source]

Run the real-time evolution with the W_I/W_II approximation.

calc_U(dt, order=2, approximation='II')[source]

Calculate self._U_MPO.

This function calculates the approximation U ~= exp(-i dt_ H) with dt_ = dt` for ``order=1, or dt_ = (1 - 1j)/2 dt and dt_ = (1 + 1j)/2 dt for order=2.

Parameters
  • dt (float) – Size of the time-step used in calculating _U

  • order (int) – The order of the algorithm. Only 1 and 2 are allowed.

  • approximation ('I' or 'II') – Type of approximation for the time evolution operator.

update(N_steps)[source]

Time evolve by N_steps steps.

Parameters

N_steps (int) – The number of time steps psi is evolved by.

Returns

trunc_err – Truncation error induced during the update.

Return type

TruncationError

get_resume_data()[source]

Return necessary data to resume a run() interrupted at a checkpoint.

At a checkpoint, you can save psi, model and options along with the data returned by this function. When the simulation aborts, you can resume it using this saved data with:

eng = AlgorithmClass(psi, model, options, resume_data=resume_data)
eng.resume_run(resume_data)

An algorithm which doesn’t support this should override resume_run to raise an Error.

Returns

resume_data – Dictionary with necessary data (apart from copies of psi, model, options) that allows to continue the simulation from where we are now.

Return type

dict

resume_run()[source]

Resume a run that was interrupted.

In case we saved an intermediate result at a checkpoint, this function allows to resume the run() of the algorithm (after re-initialization with the resume_data). Since most algorithms just have a while loop with break conditions, the default behaviour implemented here is to just call run().