|
1 | 1 | # Propagation Methods |
2 | 2 |
|
3 | | -## Chebychev Propagation |
| 3 | +```math |
| 4 | +\gdef\op#1{\hat{#1}} |
| 5 | +\gdef\ket#1{\vert{#1}\rangle} |
| 6 | +\gdef\Liouvillian{\mathcal{L}} |
| 7 | +\gdef\Re{\operatorname{Re}} |
| 8 | +\gdef\Im{\operatorname{Im}} |
| 9 | +``` |
4 | 10 |
|
5 | | -For `method=:cheby`, the time evolution operator of the piecewise-constant Schrödinger equation ``|Ψ(t)⟩ = e^{-i Ĥ dt} |Ψ(0)⟩`` is evaluated by an expansion into Chebychev polynomials [Tal-EzerJCP1984](@cite)[KosloffJCP1988](@cite). This requires ``Ĥ`` to be Hermitian (have real eigenvalues) and to have a known spectral range, so that it can be normalized to the domain ``[-1, 1]`` on which the Chebychev polynomials are defined. |
| 11 | +As discussed in the [Overview](@ref overview_approaches), time propagation can be implemented in one of two ways: |
6 | 12 |
|
7 | | -… (TODO) … |
| 13 | +1. By *analytically* solving the equation of motion and numerically evaluating the application time evolution operator. |
8 | 14 |
|
9 | | -## Newton Propagation |
| 15 | + We consider this especially in the piecewise-constant case (`pwc=true` in [`propagate`](@ref)/[`init_prop`](@ref)), which is required for the traditional optimization methods [GRAPE](https://juliaquantumcontrol.github.io/GRAPE.jl/stable/) and [Krotov](https://juliaquantumcontrol.github.io/Krotov.jl/stable/). In these propagations, the time-dependent generator ``\op{H}(t)`` is [evaluated](@ref QuantumPropagators.Controls.evaluate) to a constant operator ``\op{H}`` on each interval of the time grid. The analytical solution to the Schrödinger or Liouville equation is well known, and propagation step simply has to evaluate the application of the time evolution operator ``\op{U} = \exp[-i \op{H} dt]`` to the state ``|Ψ⟩``. The following methods are built in to `QuantumPropagators`: |
10 | 16 |
|
11 | | -For `method=:newton`, the time evolution operator of the piecewise-constant Schrödinger equation ``|Ψ(t)⟩ = e^{-i Ĥ dt} |Ψ(0)⟩`` is evaluated by an expansion into Newton polynomials [BermanJPA1992](@cite)[AshkenaziJCP1995](@cite)[Tal-EzerSJSC2007](@cite). Unlike for Chebychev polynomials, this expansion does not require ``Ĥ`` to be Hermitian or to have a known spectral radius. This makes the Newton propagation applicable to open quantum systems, where ``Ĥ`` is replaced by a Liouvillian to calculate the time evolution of the density matrix. |
| 17 | + * [`ExpProp`](@ref method_expprop) – constructs ``\op{U}`` explicitly and then applies it to ``|Ψ⟩`` |
| 18 | + * [`Cheby`](@ref method_cheby) — expansion of ``\op{U} |Ψ⟩`` into Chebychev polynomials, valid if ``\op{H}`` has real eigenvalues |
| 19 | + * [`Newton`](@ref method_newton) – expansion of ``\op{U} |Ψ⟩`` into Newton polynomials, valid if ``\op{H}`` has complex eigenvalues (non-Hermitian Hamiltonian, Liouvillian) |
12 | 20 |
|
13 | | -… (TODO) … |
| 21 | + The `ExpProp` method is generally not numerically efficient, but works well for small system for for debugging. The two "core" methods based on a polynomials series expansions are more suitable for bigger systems and provide both efficiency and high precision (in general, the is truncated as soon as some desired precision is reached, which is machine precision by default). |
14 | 22 |
|
15 | | -## Propagation with Explicit Matrix Exponentiation |
| 23 | + Note that this high precision is *within the piecewise-constant approximation*. The discretization itself may introduce a non-negligible error compared to the time-continuous dynamics. There is tradeoff: A smaller `dt` decreases the discretization error, but the polynomial expansions are more effective with larger time steps. |
16 | 24 |
|
17 | | -TODO |
| 25 | +2. By solving the equation of motion explicitly with an ODE solver. |
| 26 | + |
| 27 | + We support the use of any of the ODE solvers in [OrdinaryDiffEq.jl](https://docs.sciml.ai/OrdinaryDiffEq/stable/): |
| 28 | + |
| 29 | + * [`OrdinaryDiffEq`](@ref method_ode) – solve the equation of motion as an ODE |
| 30 | + |
| 31 | + The main benefit of using an ODE solver is that the generator ``\op{H}(t)`` can be treated as time-continuous, and thus avoid the time discretization error. While this is not compatible with traditional optimal control method like [GRAPE](https://juliaquantumcontrol.github.io/GRAPE.jl/stable/) and [Krotov](https://juliaquantumcontrol.github.io/Krotov.jl/stable/), it is suitable for control methods for tuning analytical control parameters [LucarelliPRA2018,MachnesPRL2018,SorensenPRA2018](@cite). |
| 32 | + |
| 33 | + The `method=OrdinaryDiffEq` is also available in a piecewise-constant mode by setting `pwc=true`, for comparison with `method=Cheby` and `method=Newton`. |
| 34 | + |
| 35 | + |
| 36 | +## [`ExpProp`](@id method_expprop) |
| 37 | + |
| 38 | +The method should be loaded with |
| 39 | + |
| 40 | +``` |
| 41 | +using QuantumPropagators: ExpProp |
| 42 | +``` |
| 43 | + |
| 44 | +and the passed as `method=ExpProp` to [`propagate`](@ref) or [`init_prop`](@ref): |
| 45 | + |
| 46 | +```@docs |
| 47 | +init_prop(state, generator, tlist, method::Val{:ExpProp}; kwargs...) |
| 48 | +``` |
| 49 | + |
| 50 | +**Advantages** |
| 51 | + |
| 52 | +* Simple: no knobs to turn |
| 53 | +* "Exact" to machine precision (within the piecewise constant approximation) |
| 54 | +* Does not require any special properties or knowledge of the dynamical generator |
| 55 | +* Efficient for small systems |
| 56 | + |
| 57 | +**Disadvantages** |
| 58 | + |
| 59 | +* Bad numerical scaling with the Hilbert space dimension |
| 60 | +* Method for `exp(-1im * H * dt)` must be defined (or `H` must be convertible to a type that can be exponentiated) |
| 61 | + |
| 62 | +**When to use** |
| 63 | + |
| 64 | +* Small Hilbert space dimension (<10) |
| 65 | +* Comparing against another propagator |
| 66 | + |
| 67 | + |
| 68 | +## [`Cheby`](@id method_cheby) |
| 69 | + |
| 70 | +The method should be loaded with |
| 71 | + |
| 72 | +``` |
| 73 | +using QuantumPropagators: Cheby |
| 74 | +``` |
| 75 | + |
| 76 | +and then passed as `method=Cheby` to [`propagate`](@ref) or [`init_prop`](@ref): |
| 77 | + |
| 78 | +```@docs |
| 79 | +init_prop(state, generator, tlist, method::Val{:Cheby}; kwargs...) |
| 80 | +``` |
| 81 | + |
| 82 | +The time evolution operator of the piecewise-constant Schrödinger equation ``|Ψ(t)⟩ = e^{-i Ĥ dt} |Ψ(0)⟩`` is evaluated by an expansion into Chebychev polynomials [Tal-EzerJCP1984, KosloffJCP1988](@cite). This requires ``Ĥ`` to be Hermitian (have real eigenvalues) and to have a known spectral range, so that it can be normalized to the domain ``[-1, 1]`` on which the Chebychev polynomials are defined. |
| 83 | + |
| 84 | +See [GoerzPhd2015; Chapter 3.2.1](@cite) for a detailed description of the method. |
| 85 | + |
| 86 | +**Advantages** |
| 87 | + |
| 88 | +* Very efficient for high precision and moderately large time steps |
| 89 | + |
| 90 | +**Disadvantages** |
| 91 | + |
| 92 | +* Only valid for Hermitian operators |
| 93 | +* Must be able to estimate the spectral envelope |
| 94 | + |
| 95 | +**When to use** |
| 96 | + |
| 97 | +* Closed quantum systems with piecewise constant dynamics |
| 98 | + |
| 99 | + |
| 100 | +## [`Newton`](@id method_newton) |
| 101 | + |
| 102 | +The method should be loaded with |
| 103 | + |
| 104 | +``` |
| 105 | +using QuantumPropagators: Newton |
| 106 | +``` |
| 107 | + |
| 108 | +and then passed as `method=Newton` to [`propagate`](@ref) or [`init_prop`](@ref): |
| 109 | + |
| 110 | + |
| 111 | +```@docs |
| 112 | +init_prop(state, generator, tlist, method::Val{:Newton}; kwargs...) |
| 113 | +``` |
| 114 | + |
| 115 | +The time evolution operator of the piecewise-constant Schrödinger equation ``|Ψ(t)⟩ = e^{-i Ĥ dt} |Ψ(0)⟩`` is evaluated by an expansion into Newton polynomials [BermanJPA1992, AshkenaziJCP1995, Tal-EzerSJSC2007](@cite). Unlike for Chebychev polynomials, this expansion does not require ``Ĥ`` to be Hermitian or to have a known spectral radius. This makes the Newton propagation applicable to open quantum systems, where ``Ĥ`` is replaced by a Liouvillian to calculate the time evolution of the density matrix. |
| 116 | + |
| 117 | +See [GoerzPhd2015; Chapter 3.2.2](@cite) for a detailed description of the method. |
| 118 | + |
| 119 | +**Advantages** |
| 120 | + |
| 121 | +* Reasonably efficient for high precision and moderately large time steps |
| 122 | +* Spectral radius does not need to be known |
| 123 | + |
| 124 | +**Disadvantages** |
| 125 | + |
| 126 | +* Need to choose `m_max` and `max_restarts` well for good performance. |
| 127 | + |
| 128 | +**When to use** |
| 129 | + |
| 130 | +* Open quantum systems with piecewise constant dynamics |
| 131 | + |
| 132 | + |
| 133 | +## [`OrdinaryDiffEq`](@id method_ode) |
| 134 | + |
| 135 | +The method requires that the [OrdinaryDiffEq](https://docs.sciml.ai/OrdinaryDiffEq/stable/) package is loaded |
| 136 | + |
| 137 | +``` |
| 138 | +using OrdinaryDiffEq |
| 139 | +``` |
| 140 | + |
| 141 | +Equivalently, the more general [DifferentialEquations.jl](https://docs.sciml.ai/DiffEqDocs/stable/) package can be used. |
| 142 | + |
| 143 | +``` |
| 144 | +using DifferentialEquations |
| 145 | +``` |
| 146 | + |
| 147 | +There is no difference between these two options: `OrdinaryDiffEq` is just a smaller dependency, but `DifferentialEquations` may be preferred if the large DifferentialEquations framework is required for the project. |
| 148 | + |
| 149 | +In any case, the loaded package to [`propagate`](@ref) or [`init_prop`](@ref) via the `method` keyword argument: |
| 150 | + |
| 151 | + |
| 152 | +```@docs |
| 153 | +init_prop(state, generator, tlist, method::Val{:OrdinaryDiffEq}; kwargs...) |
| 154 | +``` |
| 155 | + |
| 156 | +**Advantages** |
| 157 | + |
| 158 | +* Suitable for time-continuous dynamics |
| 159 | +* The full power of the DifferentialEquations.jl ecosystem |
| 160 | +* Efficient for moderate precisions |
| 161 | + |
| 162 | +**Disadvantages** |
| 163 | + |
| 164 | +* Less efficient for piecewise-constant dynamics, and thus less suitable of PWC control methods |
| 165 | + |
| 166 | +**When to use** |
| 167 | + |
| 168 | +* Time-continuous dynamics |
0 commit comments