Continuous-time Lindblad dynamics and open-system observables

Start with tensorcircuit/timeevol.py and the repository’s backend fixtures to understand the existing JAX ODE path and integration conventions. The proposal asks maintainers to first settle the public contract, backend coverage, and native solver versus adapter boundary; it does not identify a specific implementation file or test. Done means a scoped solver interface with the stated validation, gradient checks, and first paper example, after that design is agreed.

TEP - Continuous-time Lindblad dynamics and open-system observables

Abstract

Add a reusable continuous-time open-system workflow, starting with finite-dimensional, time-dependent Lindblad evolution. It would connect Hamiltonians, collapse operators, initial density matrices and observables to trajectories and parameter gradients. Steady states, quantum-regression correlations and stochastic trajectories would be separately scoped follow-ups.

Assessment baseline: upstream d7793995, checked on 2026-10-22. This is an idea for maintainer discussion.

Motivation and Scope

TCNG already provides density-matrix circuits, Kraus channels and Hamiltonian/time-evolution utilities. The existing ODE path is JAX-only. These components do not provide a public workflow that directly accepts a Lindblad model and returns its continuous dissipative dynamics. Users currently have to construct and validate that solver themselves or use another package.

The first milestone would support:

• Static or time-dependent finite-dimensional Hamiltonians and collapse operators, with the convention $L_k=\sqrt{\gamma_k}A_k$.
• Density-matrix initial states, requested output times, observables and integration diagnostics.
• Gradients of deterministic terminal objectives with respect to control parameters, plus JIT and batched evaluation on explicitly supported backends.
• Direct action of the Lindblad generator on the density matrix, without requiring a dense $D^2\times D^2$ Liouvillian.

Steady-state/QRT observables are the next milestone. Quantum jumps and continuous-monitoring SME/SSE require separate random-process and measurement-record contracts. Non-Markovian memory belongs in a separate process-tensor proposal.

Usage and Impact

Illustrative API for discussion only; the namespace and functions below do not exist:

import tensorcircuit as tc

def loss(parameters):
    result = tc.open_systems.lindblad_solve(
        hamiltonian=lambda t: driven_hamiltonian(t, parameters),
        collapse_operators=collapse_operators,
        initial_state=rho0,
        times=times,
        observables=observables,
    )
    return terminal_loss(result.states[-1])

compiled_loss_and_grad = tc.backend.jit(tc.backend.value_and_grad(loss))

The Hamiltonian, operators, time grid and objective are supplied by the user. This allows pulse calibration and dissipative parameter sweeps to compose with TCNG workflows.

Paper calculations enabled by the proposed stages:

Paper	Calculation TCNG cannot directly perform through an existing workflow	Proposed reproduction target
Hyyppä et al., Reducing Leakage of Single-Qubit Gates for Superconducting Quantum Processors Using Analytical Control Pulse Envelopes, PRX Quantum 5, 030353 (2024)	Four-level driven Duffing dynamics with relaxation, thermal excitation and dephasing. Appendix C explicitly uses QuTiP mesolve.	First milestone: numerical gate-error/leakage curves in Fig. 3a and 3c, using the paper's pulse and noise parameters.
Herrmann et al., Coherent Coupling of a Diamond Tin-Vacancy Center to a Tunable Open Microcavity, PRX 14, 041013 (2024)	Steady-state transmission and two-time photon correlations; Appendix E uses QuTiP.	Later steady-state/QRT milestone: theoretical curves in Fig. 4c and 4d, matching Fock cutoff and time binning.

These additions would supply the missing numerical workflows. The examples would still need the published model parameters and convergence checks; experimental data acquisition is outside scope. For the first paper, the public archive includes data and pulse helpers, but a complete master-equation reproduction script has not been confirmed.

Follow-up applications: quantum jumps and continuous monitoring. These require separately scoped stochastic solvers and measurement-record contracts.

• Xu et al., Fault-Tolerant Operation of Bosonic Qubits with Discrete-Variable Ancillae, PRX 14, 031016 (2024), use QuTiP Monte Carlo evolution for fault-tolerant operations. Their public Teleportation_Sweep.py calls mcsolve. Selected teleportation average-infidelity points in Fig. 7a would test continuous no-jump evolution, jump events, conditional operations and trajectory averaging. The script's default sampling settings still require convergence checks.
• Schmolke and Lutz, Measurement-Induced Quantum Synchronization and Multiplexing, PRL 132, 010402 (2024), motivate conditional magnetization trajectories in an eight-spin chain under continuous monitoring (Fig. 1). Deterministic ensemble evolution cannot replace this observable. The authors' software has not been confirmed; QuTiP smesolve and Dynamiqs dsmesolve are independent implementation references.
• Zhu et al., Minimalistic and scalable quantum reservoir computing enhanced with feedback, npj Quantum Information 11, 195 (2025), explicitly use QuTiP smesolve. Fig. 7a provides a complementary target for finite measurement-trajectory effects. This motivates conditional states and measurement records; the reservoir architecture remains in the example. The paper also uses an infinite-sampling deterministic limit, so this SME target should not be generalized to all its results.

Backward compatibility

Use an additive solver interface and preserve existing circuit/noise semantics. Reference packages should remain optional. Backend support must be explicit: extending the existing JAX ODE path does not establish NumPy, TensorFlow or PyTorch support.

Related Work

• QuTiP mesolve / MESolver, steadystate and correlation APIs provide direct numerical references.

• Dynamiqs mesolve already supports JAX, batching and differentiation. These capabilities alone do not justify duplicating its solver stack.

• QuantumOptics.jl timeevolution.master/master_dynamic is a Julia reference. Yao's channel primitives and PennyLane's Schrödinger pulse evolution are not equivalent Lindblad solver interfaces.

• QuTiP mcsolve.py and stochastic.py provide mcsolve and smesolve/ssesolve. Dynamiqs jssesolve.py and dsmesolve.py are JAX references for jump and diffusive trajectories; gradient support depends on the selected solver and objective.

Implementation

• Agree on the public contract, backend coverage and native-solver versus adapter boundary.
• Implement the generator through tc.backend, reuse suitable integration infrastructure, and validate trace/Hermiticity, analytical amplitude damping and the unitary limit.
• Validate parameter gradients independently and compare against QuTiP/Dynamiqs at matched numerical error. Separate compilation time, execution time and memory.
• Add the first paper example, API documentation and changelog entry. Use repository backend fixtures and highp where needed; run the required checks for the eventual code PR.
• Design steady-state/QRT separately, including how non-unique steady states are handled. Regression must propagate unnormalized, potentially non-Hermitian auxiliary operators such as $B\rho$ without forcing their trace to one.
• For jump/SME solvers, define monitored and unmonitored channels, monitoring efficiencies, explicit random keys, conditional states and measurement/jump records.
• Validate stochastic ensemble averages against the corresponding master equation, as well as waiting-time or measurement-record statistics. Identical integer seeds in different packages do not imply identical trajectories. Separate stochastic time-discretization error from Monte Carlo uncertainty.

Alternatives

A thin optional Dynamiqs/QuTiP adapter may deliver more value than a new integrator. Discrete noisy circuits can approximate some models after a separate discretization analysis, but do not supply the requested continuous-time interface.

Questions for maintainers: Is a native Lindblad model/solver interface useful enough to add? Should the first implementation reuse the current JAX ODE path or wrap an external solver? Should steady-state/QRT be a separate TEP?

References

• Hyyppä et al., Appendix C.
• Herrmann et al., Appendix E.
• TCNG contributor guide.