Generic Super-Operators

When a system's evolution doesn't fit the built-in Schrödinger or Lindblad forms, assemble the equation of motion yourself from SuperOperator terms that act on the density matrix from the left, the right, or both sides.

What a super-operator is

A super-operator is a linear map that takes the density matrix ρ and returns dρ/dt. Any master equation can be written as a sum of three primitive actions — left multiplication L·ρ, right multiplication ρ·R, and sandwiched multiplication L·ρ·R. qalgora.SuperOperator lets you add those terms directly, lifting the restriction to the Hamiltonian-plus-collapse-operator template.

Rebuilding the von Neumann equation

The closed-system law dρ/dt = −i[H, ρ] is just two terms:

import qalgora
from qalgora import operators, Schedule
import numpy as np

H = 2.0 * np.pi * 0.1 * operators.spin.z(0)

psi0 = np.array([1.0, 0.0], dtype=complex)
rho0 = np.outer(psi0, psi0.conj())                     # a density matrix

sop = qalgora.SuperOperator()
sop += qalgora.SuperOperator.left_multiply(-1j * H)    # -i H rho
sop += qalgora.SuperOperator.right_multiply(1j * H)    #  +i rho H

result = qalgora.evolve(
    sop, dimensions={0: 2},
    schedule=Schedule(steps=np.linspace(0, 1, 100), parameters=["t"]),
    initial_state=qalgora.State.from_data(rho0),       # a density matrix
    observables=[operators.spin.z(0)],
)

Adding a custom dissipator

The sandwiched term L·ρ·L^† is exactly what a Lindblad jump operator needs. Here is amplitude damping written by hand — equivalent to passing a collapse operator, but every term is under your control. These terms continue the sop built in the von Neumann example above; start a fresh sop = qalgora.SuperOperator() if you want the dissipator alone.

gamma = 0.05
L = operators.boson.annihilate(0)             # lowering / loss operator
Ldag = operators.boson.create(0)
LdagL = Ldag * L                              # operator product (use @ if these are dense matrices)

sop += gamma * qalgora.SuperOperator.left_right_multiply(L, Ldag)    #  gamma L rho L^dag
sop += qalgora.SuperOperator.left_multiply(-0.5 * gamma * LdagL)     # -gamma/2 (L^dag L) rho
sop += qalgora.SuperOperator.right_multiply(-0.5 * gamma * LdagL)    # -gamma/2 rho (L^dag L)

When to reach for it