Process Tensors

A process tensor is the central object used to describe a quantum system that is probed, controlled, measured, or otherwise intervened on at multiple times while it remains coupled to an environment.

The goal of this page is to explain what a process tensor is, why it naturally describes non-Markovian open quantum dynamics, and how the same object appears in ProcessTensors.jl as a tensor network with time steps, input/output legs, memory links, and instruments.

For the Hilbert-space, density-matrix, and Liouville-space conventions used in this package, see Quantum States and Liouville Space.

From channels to multi-time processes

A quantum state is represented by a density matrix $\rho$. A quantum channel is a physical transformation that maps input states to output states:

\[\rho' = \Phi(\rho).\]

For deterministic dynamics, $\Phi$ is usually required to be Completely Positive and Trace Preserving (CPTP). The Local Master Equation, and the closed unitary dynamics of $\rho$ given by Von-Neuman equations are examples of channels.

In this sense, an ordinary channel answers a one-time question: Given the state now, what is the state later?

We can extend this and ask a more operational question: Given the operations performed on the system at several earlier times, what state, or outcome do we obtain later?

To express this idea cleanly, it is useful to introduce the language of superchannels. A channel maps states to states. A superchannel is a higher-order transformation that takes quantum channels as inputs and returns a state output. In this sense, a process tensor is a multi-time superchannel: it takes the operations inserted at different times as its inputs.

Schematically,

\[\mathcal{T}_{n:0} [ \mathcal{A}_{n-1}, \ldots, \mathcal{A}_0 ] = \rho_n.\]

Here $\mathcal{A}_k$ is the operation inserted at time $t_k$, and $\rho_n$ is the resulting output state at the final time $t_n$. If the final output is also measured or traced out, the same process tensor gives a scalar probability or expectation value instead.

Multi-time process tensor:

      A₀        A₁        A₂
      │         │         │
      ▼         ▼         ▼
    [ process tensor with memory ] ──> ρ₃

A process tensor over times $t_0,\ldots,t_n$ can therefore be read as a higher-order object that accepts a sequence of operations:

\[\mathcal{T}_{n:0} : ( \mathcal{A}_{n-1}, \ldots, \mathcal{A}_0 ) \mapsto \rho_n.\]

Equivalently,

\[\rho_n = \mathcal{T}_{n:0} [ \mathcal{A}_{n-1}, \ldots, \mathcal{A}_0 ].\]

If the operations are selected from instruments with outcomes $x_0,\ldots,x_{n-1}$, and the final output is closed, the process tensor gives a joint probability:

\[p(x_{n-1},\ldots,x_0) = \mathcal{T}_{n:0} [ \mathcal{A}_{n-1}^{(x_{n-1})}, \ldots, \mathcal{A}_0^{(x_0)} ].\]

In a Choi-state representation, the process tensor is often denoted by $\Upsilon_{n:0}$. The corresponding generalised Born rule has the schematic form

\[p(\mathbf{x}) = \operatorname{Tr} \left[ \Upsilon_{n:0} \left( \mathsf{A}_{n-1}^{(x_{n-1})} \otimes \cdots \otimes \mathsf{A}_0^{(x_0)} \right) \right],\]

up to transpose and index-ordering conventions fixed by the chosen Choi or Liouville representation. Here $\mathsf{A}_k^{(x_k)}$ denotes the Choi or Liouville representation of the operation inserted at time $t_k$.

Non-Markovian dynamics and process tensors

If an open quantum system is effectively memoryless, one often describes its reduced dynamics by a chain of state-to-state maps:

\[\rho_{k+1} = \Phi_{k+1:k} \left[ \rho_k \right].\]

This is the Markovian intuition: the future depends only on the present reduced state.

But for a system coupled to a bath, the system and bath can become correlated. If the bath retains information about previous system states or previous interventions, then the transformation from $t_k$ to $t_{k+1}$ is not determined only by $\rho_k$.

In such a case, the later state may depend on the full history of operations:

\[\rho_n = \mathcal{T}_{n:0} [ \mathcal{A}_{n-1}, \ldots, \mathcal{A}_0 ].\]

This is the operational meaning of memory: later statistics can depend on what was done to the system at earlier times.

Markovian picture:

ρ₀ ── Φ₁ ──> ρ₁ ── Φ₂ ──> ρ₂ ── Φ₃ ──> ρ₃


Non-Markovian process picture:

A₀        A₁        A₂
│         │         │
▼         ▼         ▼
[slot 0]─m₁─[slot 1]─m₂─[slot 2]─m₃─> output

memory links carry history

The most common physical origin of a process tensor is a system $S$ interacting with a bath $B$. Suppose the joint system-bath state at the initial time is $\rho_{SB}(t_0)$. Between interventions, the joint state evolves under system-bath propagators. In superoperator notation,

\[\mathcal{U}_{k+1:k}(\cdot) = U_{k+1:k} (\cdot) U_{k+1:k}^{\dagger}.\]

At each time $t_k$, the user may apply an operation $\mathcal{A}_k$ to the system. The bath is not directly controlled, so the operation acts as $\mathcal{A}_k\otimes\mathcal{I}_B$ on the joint state.

The final reduced system state is

\[\rho_S(t_n) = \operatorname{Tr}_B \left[ \mathcal{U}_{n:n-1} \left( \mathcal{A}_{n-1}\otimes\mathcal{I}_B \right) \cdots \mathcal{U}_{1:0} \left( \mathcal{A}_{0}\otimes\mathcal{I}_B \right) \rho_{SB}(t_0) \right].\]

This equation is the key construction. The process tensor is what remains when all the system-bath evolution and bath trace are packaged into a reusable object with open slots for the system operations $\mathcal{A}_k$.

System-bath origin of a process tensor:

ρ_SB(t₀)
   │
   ▼
[A₀ on S] ── U₁:₀ ── [A₁ on S] ── U₂:₁ ── [A₂ on S] ── U₃:₂
                                                               │
                                                               ▼
                                                         Tr_B at end

The bath is not directly controlled, but it carries memory between time steps.

A Markovian process is a special case of the process-tensor framework. In this case, the multi-time process factorises into independent step-to-step channels:

\[\mathcal{T}_{n:0}^{\mathrm{Markov}} \sim \Phi_{n:n-1} \otimes \Phi_{n-1:n-2} \otimes \cdots \otimes \Phi_{1:0}.\]

There is no non-trivial memory link carrying information between interventions. In a non-Markovian process, this factorisation fails. The memory links are non-trivial, and the effect of an operation at one time can influence later reduced dynamics.

Markovian temporal structure:

[Φ₁]   [Φ₂]   [Φ₃]

no memory links between interventions


Non-Markovian temporal structure:

[PT₀]──m₁──[PT₁]──m₂──[PT₂]──m₃──[PT₃]

memory links carry temporal correlations

Anatomy of a process tensor

In tensor-network form, a process tensor has an input and output leg at each time slot.

The input leg represents the system state entering that time slot. The output leg represents the system state leaving that time slot. The operation inserted by the user connects the input-output structure associated with that time.

A memory link connects neighbouring process-tensor cores. It stores compressed information about the bath influence and the history of previous interactions.

One process-tensor core:

              output leg
                  │
left memory ── [ PTₖ ] ── right memory
                  │
               input leg

A multi-time process tensor becomes a chain in time:

Process tensor as a temporal tensor network:

out₀       out₁       out₂       out₃
 │          │          │          │
[PT₀]--m₁--[PT₁]--m₂--[PT₂]--m₃--[PT₃]
 │          │          │          │
in₀        in₁        in₂        in₃

The memory bond dimensions determine how much temporal correlation is stored. A small memory bond corresponds to a compact process. A large memory bond means the bath influence or intervention history is harder to compress.

pt = build_process_tensor(system; environment, dt, nsteps)

Instruments in process-tensor slots

An instrument is inserted into the open legs of a process tensor. It represents the operation performed on the system at a given time.

Common examples include:

Instrument contraction:

        A₀          A₁          A₂
        │           │           │
out₀    │   out₁    │   out₂    │
 │      │    │      │    │      │
[PT₀]--m₁--[PT₁]--m₂--[PT₂]--m₃--[PT₃]
 │           │           │
in₀         in₁         in₂

The process tensor itself stores the environment-mediated multi-time structure. The instruments specify what the user does to the system.

seq = InstrumentSeq(default=identity_operation(), nsteps=pt.nsteps)
add!(seq, state_preparation(ρ0), 0)
add!(seq, identity_operation(), 1)

Evaluating a process tensor

Evaluating a process tensor means contracting it with an instrument sequence.

If all relevant legs are closed, the result is a scalar. This scalar may be a probability, expectation value, or correlation value depending on the inserted instruments.

All legs closed:

[A₀]      [A₁]      [A₂]      [A₃]
 │         │         │         │
[PT₀]--m--[PT₁]--m--[PT₂]--m--[PT₃]
 │         │         │         │
closed    closed    closed    closed

Result: scalar

If one output is left open, the result is a reduced system object at that time.

One output left open:

[A₀]      [A₁]       open
 │         │          │
[PT₀]--m--[PT₁]--m--[PT₂]
 │         │          │
closed    closed     input/trace structure

Result: reduced state or Liouville-space object

Reduced time evolution is a special process-tensor contraction pattern. If the first instrument prepares an initial state, and later slots are filled with identity, trace-out, or propagation instruments, the process tensor returns the reduced system trajectory.

Reduced evolution picture:

ρ₀ ── [PT₀] ──> ρ₁ ── [PT₁] ──> ρ₂ ── [PT₂] ──> ρ₃

In package language, this is the difference between the general and convenience workflows:

# General process contraction
evaluate_process(pt, seq)

# Common reduced-evolution workflow
evolve(pt, ρ0)

The second is not a different physical theory. It is a frequently used contraction of the same process tensor.

Multi-time observables and correlations

Process tensors are useful for multi-time quantities because they keep intervention slots open. For example, a two-time quantity may be computed by inserting one operation at $t_1$ and another at $t_2$.

Two-time operator insertion:

              B insertion              A insertion / trace
                   │                         │
[PT₀]──m──[PT₁]──m──[PT₂]──m──[PT₃]──m──[PT₄]

The precise instrument depends on what correlation is desired. A projective measurement, an observable insertion, and a left/right operator action are not the same operation.

seq = two_time_correlation_seq(pt, (O, t2), (O, t1); rho0=ρ0)

Physical properties

A physical process tensor is not an arbitrary tensor. It must satisfy structural conditions inherited from quantum mechanics and causality.

• Complete positivity. If completely positive operations are inserted into the process tensor, the resulting state or probability must be physical. In Choi-like representations, this is reflected by positivity of the process tensor object.

• Normalisation. If a complete deterministic set of operations is inserted at every time, probabilities must normalise correctly. Equivalently, inserting trace-preserving operations should not create or destroy total probability.

• Causality. Future interventions cannot change earlier observed statistics. Operationally, if all future slots are closed with trace-preserving operations, then the probabilities for earlier outcomes must remain unchanged.

Causality intuition:

past instruments       current statistics       future slots closed
      A₀, A₁                   ?                   Tr, Tr, Tr
        │                      │                    │   │   │
     [PT₀]──m──[PT₁]──m──[PT₂]──m──[PT₃]──m──[PT₄]──m──[PT₅]

Future trace-preserving closures cannot signal backwards in time.

How this appears in ProcessTensors.jl

ProcessTensors.jl constructs process tensors from microscopic ingredients such as system sites, bath modes, system-bath couplings, time steps, and propagation rules.

The package workflow is conceptually:

define system + bath + coupling
          │
          ▼
build_process_tensor(...)
          │
          ▼
ProcessTensor
          │
   ┌──────┴─────────┐
   ▼                ▼
evolve(...)    evaluate_process(...)

The important package objects are:

The theory is the same regardless of the implementation details: the process tensor stores the reusable environment influence, and instruments specify what is done to the system.

Further reading

This page is a compact guide to the process-tensor language used in the package. For deeper study, the following references are useful.

Process tensors and quantum stochastic processes

1. F. A. Pollock, C. Rodríguez-Rosario, T. Frauenheim, M. Paternostro, and K. Modi, “Non-Markovian quantum processes: complete framework and efficient characterisation.”

   Foundational process-tensor reference. Useful for understanding how multi-time quantum processes with memory can be characterised operationally and represented as many-body quantum states.

2. F. A. Pollock, C. Rodríguez-Rosario, T. Frauenheim, M. Paternostro, and K. Modi, “Operational Markov condition for quantum processes.”

   Important reference for the operational definition of quantum Markovianity and the causal structure of process tensors.

3. S. Milz and K. Modi, “Quantum stochastic processes and quantum non-Markovian phenomena.”

   A pedagogical tutorial connecting classical stochastic processes, quantum combs, process tensors, and non-Markovian quantum phenomena.

Higher-order quantum operations and quantum combs

1. P. Taranto, S. Milz, M. Murao, M. T. Quintino, and K. Modi, “Higher-Order Quantum Operations.”

   A broad review article on higher-order quantum operations, including superchannels, combs, process tensors, and their physical applications.

2. G. Chiribella, G. M. D'Ariano, and P. Perinotti, “Theoretical framework for quantum networks.”

   A foundational reference for quantum combs, link products, and higher-order transformations of quantum operations.

3. G. Chiribella, G. M. D'Ariano, and P. Perinotti, “Quantum Circuit Architecture.”

   Useful background for understanding how networks of quantum operations can be treated as higher-order quantum objects.

Tensor-network process-tensor methods

1. A. Strathearn, P. Kirton, D. Kilda, J. Keeling, and B. W. Lovett, “Efficient non-Markovian quantum dynamics using time-evolving matrix product operators.”

   Introduces the TEMPO approach, which represents environment influence using matrix product operators in time.

2. M. Cygorek, M. Cosacchi, A. Vagov, V. M. Axt, B. W. Lovett, J. Keeling, and E. M. Gauger, “Numerically exact open quantum systems simulations for arbitrary environments using automated compression of environments.”

   Introduces automated compression of environments, a process-tensor-based method for constructing and compressing environmental influence.

3. G. E. Fux, D. Kilda, B. W. Lovett, and J. Keeling, “Tensor network simulation of chains of non-Markovian open quantum systems.”

   Useful follow-up for readers interested in combining process tensors with tensor-network simulations of interacting chains.