Source-linked AI summary
Exploiting the causal tensor network structure of quantum processes to efficiently simulate non-Markovian path integrals
Mathias R. Jørgensen, Felix A. Pollock
TL;DR
The paper examines how memory decay and network representation affect the complexity of simulating non-Markovian dynamics. It develops SVD-based tensor-network compression and compares local and non-local representations, finding that the local representation is faster across parameters and avoids the non-local network’s growth in iteration time.
Problem
The algorithm’s complexity depends on how quickly memory effects decay and on the effective depth of the tensor network.
Method
The approach compresses boundary matrix product operators by sweeping through their local tensors with singular-value decomposition and compares local with non-local network representations.
Results
The local TEMPO representation has a non-increasing iteration cost for finite networks, whereas the non-local cost grows approximately linearly and remains slower across a wide parameter range.
Takeaways & Limitations
Network locality reduces contraction time even in weak-coupling, small-cutoff-frequency regimes, while memory-time complexity follows the decay of the memory kernel.
Abstract
from arXiv · showhide
In the path integral formulation of the evolution of an open quantum system coupled to a Gaussian, non-interacting environment, the dynamical contribution of the latter is encoded in an object called the influence functional. Here, we relate the influence functional to the process tensor -- a more general representation of a quantum stochastic process -- describing the evolution. We then use this connection to motivate a tensor network algorithm for the simulation of multi-time correlations in open systems, building on recent work where the influence functional is represented in terms of time evolving matrix product operators. By exploiting the symmetries of the influence functional, we are able to use our algorithm to achieve orders-of-magnitude improvement in the efficiency of the resulting numerical simulation. Our improved algorithm is then applied to compute exact phonon emission spectra for the spin-boson model with strong coupling, demonstrating a significant divergence from spectra derived under commonly used assumptions of memorylessness.
Appendix A: Process tensor formalism.
The process tensor is a Choi-state representation of open-system evolution that separates the process from external interventions and encodes multi-time dynamics.
- Process tensor formalism: Only completely positive superoperators correspond to physically realizable transformations, although the formalism can represent arbitrary superoperators.
- Process tensor formalism: Choosing A_j[ρ] = A_jρB_j yields multi-time Heisenberg-picture correlation functions, while setting all A_j = I recovers free evolution.
- Process tensor formalism: The process tensor is constructed from the underlying system-environment dynamics by inserting identities around unitary evolutions and tracing over the environment.
- Process tensor formalism: The process tensor represents open-system evolution independently of the applied superoperators, while their choices determine the measured dynamical properties.It includes freely evolved states and multi-time correlation functions as special cases of intervention choices.
- Process tensor formalism: Its Choi representation is a positive many-body operator whose temporal correlations correspond to correlations between subsystems.
Appendix B: Connection with influence functional
For short time steps, Trotter decomposition and a factorizing initial state convert the system-environment process into a discretized influence functional.
- Connection with influence functional: Trotter decomposition separates system and interaction evolution, enabling the process-tensor expression to be expanded into an influence-functional form.
- Connection with influence functional: Assuming χ0 = ρ0 ⊗ τ produces a factorized initial condition for the approximate process used to derive the influence functional.
- Connection with influence functional: When the bath coupling is diagonal in the system basis, the expanded expression reduces to the discretized Feynman–Vernon influence functional for time-independent, evenly spaced evolution.
Appendix C: Explicit form of influence tensors in the spin-boson model
For a Gaussian environment with linear system coupling, Wick’s theorem factorizes the influence functional into explicit tensors determined by bath correlations.
- Explicit influence tensors: Gaussian bath states and linear system-bath coupling are the conditions required to factorize the influence functional into a product of influence tensors.
- Explicit influence tensors: For the spin-boson Hamiltonian with a thermal Gaussian bath, the influence tensors can be computed explicitly from interaction-picture bath operators.
- Explicit influence tensors: Time-translation invariance makes each influence tensor depend only on the difference between time steps, reducing the number of distinct tensors.
- Explicit influence tensors: The tensor elements are expressed through the environment autocorrelation function and the spectral density.
Appendix D: Tensor network compression
The compression procedure approximates boundary matrix product operators by truncating small singular values during iterative network contraction.
- Tensor network compression: SVD compression replaces local tensors with lower-rank approximations by discarding singular values below the cutoff λc.The cutoff controls the truncation error and the resulting bond dimensions.
- Tensor network compression: The local tensor decomposition uses diagonal singular-value matrix Λ and rectangular isometries U and V satisfying U†U = 1 and V†V = 1.
- Tensor network compression: After truncation, the retained factors are contracted into a new matrix Q that represents the compressed local tensor.
- Tensor network compression: Compression sweeps across the boundary MPO from one end to the other, repeatedly decomposing, truncating, and contracting neighboring tensors.
Appendix E: Scaling of memory effects with physical parameters
The appendix relates contraction complexity to memory-kernel decay and overall bath coupling, showing distinct scaling regimes with the cutoff frequency.
- Memory-kernel decay: For the chosen Ohmic spectral density, the memory kernel decays as a power law rather than exponentially.This changes how the required memory time scales with network size and target error.
- Memory-kernel decay: For fixed error, the power-law regime gives a memory-time and complexity bound controlled by the cutoff frequency, coupling, temperature, and network length.The bound follows from ε_m ≲ αk/(πβω_c m) and the resulting scaling discussed after it.
- Scaling regimes: The onset of the asymptotic scaling depends on parameter combinations including ω_ct and temperature-related scales.Thus, the limiting expressions do not apply uniformly across all parameter choices.
- Small-cutoff regime: When ω_c is small, ε_m ≲ (αω_c/πβ)(t_max−t_m)^2, so the truncation error vanishes with ω_c at fixed evolution time.The appendix attributes this behavior to weak overall bath coupling, even when memory times are short.
Appendix F: Scaling comparison
The local network representation avoids the iteration-dependent growth seen in the non-local algorithm and remains faster across the tested parameter range.
- Per-iteration scaling: The non-local algorithm’s computation time per iteration grows approximately linearly, whereas the local algorithm rapidly reaches a non-increasing value.The non-local growth is attributed mainly to irrelevant information accumulating in the representation.
- Parameter-range comparison: The local representation remains faster across couplings and cutoff frequencies, including weak coupling and small cutoff frequency.Figure 4d compares total contraction times over the parameter range, while the text states that the advantage persists broadly.
- Implementation: The simulations used a Python implementation on a 2011 MacBook Pro without specialized tensor-network packages, leaving scope for further optimization.The implementation used NumPy and standard hardware.