Initial state

Without interactions, the system may be completely decoupled along its axes, and we can consider the reduced density matrix (where is properly normalized) and describe the physics as if it were in 1D. The system is then described by the quantum harmonic oscillator Hamiltonian, written in terms of the standard ladder operators satisfying . The eigenstates have a well known representation in the position basis, , in terms of the physicists’ Hermite functions, ,

where are the Hermite polynomials and is the natural length scale of the harmonic oscillator.

begin
    # efficient computation of Hermite functions using recurrence relations
    function hermite(n, x)
        iszero(n) && return (π)^(-0.25) * exp(-x^2 / 2)
        isone(n) && return sqrt(2) * x * π^(-0.25) * exp(-x^2 / 2)

        hi, hj = hermite(1, x), hermite(0, x)

        for k in 2:n
            hj = sqrt(2 / k) * x * hi - sqrt((k - 1) / k) * hj
            hi, hj = hj, hi
        end

        return hi
    end

    ns = 0:10
    xs = -6:0.01:6
    plot(xs, 2.5 * hermite.(ns', xs) .^ 2 .+ ns' .+ 0.5, lab="", line_z=ns', color=:rainbow)
    plot!(x -> 0.5 * x^2, xs, c=:black, lw=1.5, ls=:dash, alpha=0.3, lab="")
    plot!(framestyle=:box, ylim=[0, last(ns) * 1.15], yticks=nothing, xlabel="Position (x/lh)", colorbartitle="Hermite mode", title="Hermite mode density profiles", ylabel="Density", margins=5Plots.mm)
end

The state of the system at thermal equilibrium within the canonical ensemble is written as a density matrix , where . It is naturally diagonal in the basis,

where we have the Boltzmann factor, .

Time-of-flight imaging

However, in cold atom experiments, typically the measurement is not done in-situ since the atom densities are often too large resulting in saturation of the absorption of the light used for imaging. In order to reduce the density, we typically release the cloud from the harmonic trap and allow it to expand ballistically and image it after some time known as the time-of-flight. For a generic density matrix, this may change the spatial density arbitrarily. Let us see how this affects our thermal state, which now evolves under the free particle Hamiltonian, ,

We now need to compute how the Hermite functions propagate under the free particle Hamiltonian.

where, is the Fourier transform of the harmonic oscillator eigenstates.

Epilogue

Over the course of this article, we’ve noticed two elegant results that seemingly arise as mathematical flukes. The first is that an exponentially weighted sum of Hermite functions neatly converges to a Gaussian, and the second is that the free evolution of the thermal state behaves remarkably classically. Perhaps there is something more fundamental going on here? We will tackle this in the next post!

Setting up the problem

Consider a set of second-quantized creation operators which satisfy the canonical (anti-)commutation relations (CCR), depending on whether they describe bosons or fermions. Suppose we are interested in a system described by a Hamiltonian that is quadratic in these operators, . Generically, this may be cast into a matrix equation like so (upto some constant terms),

where is generally an Hermitian matrix and is an anti-symmetric matrix describing pairing terms. The positive (negative) sign corresponds to bosons (fermions) due to the CCR. Note that we have introduced a stacked ‘Nambu’ vector such that the CCR is now written as follows

where since consists of both creation and annihilation operators.

In such a case, it is convenient to look for the energy spectrum of the system by finding a new set of operators, related to through a linear transformation (note that we interpret and as column and row vectors, respectively):

such that where is diagonal. The transformation must chosen such that also satisfies the CCR in order to ensure a physical interpretation. This is the general framework of Bogoliubov transformations.

Solving for the energy spectrum

Such a transformation necessarily mixes the creation and annihilation operators and invites the interpretation of quasi-particles that have characteristics of holes and particles created by the original operators. In some places, this procedure can be referred to as ‘diagonalizing’ the system, i.e, solving the free part, but such a notion typically adds to the confusion because is not a similarity transform in general.

We now introduce such that . The constraint on follows from a simple calculation enforcing the CCR.

which means that This tells us that for bosons, the complex symplectic group, while for fermions, , the unitary group. Note that this holds for the inverse transformation as well (i.e, ). Perhaps rather notably, for fermions this remains a similarity transform, so the eigenvalues may simply be obtained by unitarily diagonalizing , however, for bosons, it is necessarily different.

We now need to identify an appropriate such that is diagonal. This can be done with some simple manipulations as follows. Since we have , it follows that . Then,

Since is diagonal, we know that remains diagonal. Writing in terms of its column vectors, we now have:

which is a normal eigenvalue equation where we diagonalize the matrix, for both bosons and fermions. We can actually infer something about the spectrum in general using the structure of . In both cases, we have where,

This immediately means that for every eigenvector with eigenvalue , there is a corresponding pair with eigenvalue in . The physical spectrum is then given by .

In the case of fermions, , so the ground state already has all negative energy states occupied, with the remaining positive energies indicating physical excitations. The structure in the eigenvalues is interpreted as a manifestation of particle-hole symmetry in the original Hamiltonian . For bosons on the other hand, the flips back the negative half of the spectrum, seemingly resulting in a doubly degenerate spectrum of positive energies in . This degeneracy, however, simply results from doubling the size of the Hamiltonian while constructing and there are only physically distinct excitations.

Do bosons and fermions agree on anything?

Before wrapping up, let us consider the case when a transformation may be valid for both bosons and fermions, i.e, it is both symplectic and unitary over matrices. Suppose we consider a general Bogoliubov transformation as follows (since , considering both cases as column vectors as they are stacked in ),

From the bosonic and fermionic constraints, we have and , respectively. Then , which immediately enforces . The fermionic constraint then implies unitarity on the remaining blocks, . We then have,

which is a unitary transformation acting purely at the single particle level without mixing the creation and annihilation operators. This is perfectly consistent, since one would expect that the only transformations that are not affected by the exchange statistics must be a basis change of the single particle orbitals.

Characterizing superfluidity

When I think about superfluidity, few of the phenomena that immediately come to mind are superleaks and supercreep, where the fluid is able to seep through the pores of the container and climb out of the walls of the container respectively. While these are certainly the most eye-catching phenomena, they are not particularly nice to work with in a theoretical framework. Perhaps a more wieldy (and practically interesting) manifestation of superfluidity is the persistence of metastable currents.

Suppose we have a cylindrical bucket filled with a superfluid and it is rotated rapidly. If the rotation is now suddenly stopped, the fluid continues rotating for long time-scales without any dissipation! Such an effect is typically explained through the existence of quantized vortices in such superfluids (which generally arise due to the existence of a condensate, but we will come back to this). It is also fundamentally a dynamical/kinetic phenomena since it requires the existence of energy barriers that prevent decay to the true ground state of the system.

We instead consider another closely related phenomena that is defined in an equilibrium setting, namely the Hess-Fairbank effect (its superconducting analogue is the Meissner effect). Suppose the bucket is initially at rest and is then rotated at a very small angular velocity (upto some critical threshold that is determined by the geometry of the setup). Once the system has equilibriated, if we measure the moment of inertia of the system, it would be smaller than the expected value of a classical fluid!

This lends itself to a phenomenological description of the system in terms of the well known two-fluid model, where the system behaves as a composite of a superfluid with density that carries no entropy or viscosity and the normal fluid with density that behaves as a classical fluid. In the context of this experiment, the superfluid fraction would simply remain at rest despite the rotation of the container walls, resulting in a reduction of the measured moment of inertia. Such a hydrodynamic treatment elevates the superfluid density and velocity to thermodynamic variables and serves as an effective field theory for the system dynamics at a coarse level. While this has had enormous success in explaining a ton of experimental predictions, it is also prominently featured in most introductory texts on the topic. In this post we will instead consider a less advertised, but heavily used approach to relate this superfluid fraction with microscopic features of the system without making references to viscosity or other dynamical responses.

(Note: It must be kept in mind that superfluidity really evolved as a phenomenological field first to keep up with experimental observations, followed by more microscopic treatments to bridge the gaps. As such, there are several ways to characterize the superfluid behaviour depending on the specific system, not all of which may result in equivalent descriptions. For instance, in lower dimensions or non-interacting systems, one may observe Hess-Fairbank but not metastable currents. On the other hand, we have things like the Landau criterion that characterizes dissipation through a restriction on the excitation spectrum, but is neither necessary nor sufficient for superfluidity. Finally, there is an equivalence typically made that a Bose-Einstein condensate is a superfluid due to its ability to support quantized vortices, but this need not always be the case, especially in lower dimensions. The point here is that there are nuances involved in making broad sweeping claims about what constitutes a superfluid, so in this post we really just consider some subset of superfluids that exhibit the Hess-Fairbank effect as a defining feature.)

Arriving at a microscopic definition

Let us consider interacting bosons on a ring of radius . In order to impart angular momentum to the system, we model the interaction between the bosons and the walls of the ring with a weak potential that is rotating with an angular velocity with a strength .

In order to treat this system in a time-independent setting, we move over to the co-rotating frame of reference through a transformation where is the angular momentum operator of the boson.

Since the potential is very weak and only serves the purpose of imparting momentum such that the system may reach equilibrium, we can ignore it henceforth (one may imagine a process where the system is brought to equilibrium and then is turned off adiabatically). Now, suppose the angular velocity is small such that the superfluid fraction remains at rest in the lab frame. Then in the rotating frame, one would expect the mechanical angular momentum where is the classical moment of inertia. Note that where is the canonical momentum, equivalent to the mechanical momentum as measured in the lab frame.

To find the relation between these angular momenta, we notice that since the Hamiltonian in the rotating frame has changed, the commutation relation between the canonical linear momentum and the position operator has changed as well. Working in the Heisenberg picture, we have the velocity operator in the rotating frame, where we notice an extra centrifugal contribution as expected. This immediately gives us , which is exactly what we would expect since the angular momentum as measured from the lab frame would only have contributions from the normal fraction. Now, to relate this with a measurable property of the system, we use the Hellman-Feynman theorem:

We thus notice that the second derivative of the energy with respect to the angular momentum gives us the normal fraction of the system. However, at this point we must realize that the fact that this relation arose specifically from a rotating setup is simply obfuscating a more general property of the ground state of the system. We can see this more clearly if we rewrite the Hamiltonian in the rotating frame in a slightly different manner;

We see that in this form, the rotation simply acts as an artifical gauge field . It is an artificial one since it additionally alters the Hamiltonian by adding a centrifugal term (which is exactly what gives rise to the term in our expression for ). This is also where we may draw a parallel with superconductivity where the role of the gauge field is played by the magnetic vector potential instead.

At this point, we can recover the original Hamiltonian (upto the centrifugal term) by simply performing the following transformation . This gets rid of the gauge potential term, and transfers the burden onto the boundary conditions instead. While the system original obeyed periodic boundary conditions where , we now have twisted boundary conditions where . Now we can forget that we arrived here from the context of a rotating system (and along with it, throw away the annoying centrifugal term that has been tagging along) and cast this result in a completely abstract manner.

The superfluid fraction is then defined like so (there are proportionality factors depending on the system size, etc, that I have not explicitly written):

Where is the ground state energy of the original Hamiltonian under twisted boundary conditions . We thus see that the superfluid response of a system is not really tied to rotation specifically, but rather to the resistance of the system to phase twists. If the energy remains the same under a twist, the system does not exhibit superfluidity. This notion somehow ties in nicely with our intuitive understanding that superfluidity is closely related to the phase of the system (generally the superfluid velocity can be written as the gradient of the phase of a condensate wave-function).

Why bother?

While at a first glance, this definition seems really abstract and not very useful, it actually opens up a lot of things to explore. We now consider a few possibilities.

A numerical proxy for superfluidity

Numerical simulations of 1D systems readily have access to the ground state energy of the Hamiltonian. As a result, one may easily extract the superfluid fraction as defined above. We can take a quick look at this for a mean-field treatment of the Bose-Hubbard model. I directly present the code here as the accompanying explanations are detailed in a previous post.

# cutoff necessary since bosonic space is infinite dimensional
mean_field_ops(nmax) = (diagm(1 => sqrt.(1:nmax)), diagm(0 => 0:nmax))

BHM(â, n̂; t, mu, psi, U=1.0) = -mu * n̂ + 0.5 * U * n̂ * (n̂ - I) - 2t * psi * (â + â') + 2t * psi^2 * I

function solve(â, n̂, H; atol=1e-8, callback=identity)
    # initial guess
    state = rand(eltype(â), size(â, 1))
    psi = state' * â * state
    psi_old = psi

    while true
        ## f(psi)
        state = eigvecs(H(psi))[:, 1]
        state ./= sqrt(norm(state))
        psi = state' * â * state
        ##

        # check convergence
        (norm(psi - psi_old) < atol) && break
        psi_old = psi

        # for injecting other custom logic later on; by default it does nothing
        callback(psi)
    end

    return state, psi
end

solve(â, n̂; t, mu, atol=1e-8) = solve(â, n̂, psi -> BHM(â, n̂, t=t, mu=mu, psi=psi), atol=atol)

solve (generic function with 2 methods)

We now add a simple function to compute the second derivative of the energy under a phase twist using a finite-difference scheme. Note that since we work directly in the thermodynamic limit, it is a bit finicky to work with conditions on the boundaries. Instead, we may consider applying on each site of the original Hamiltonian. This preserves the translation invariance of the system and is equivalent to applying a phase twist of at the boundaries, where is the length of the chain. At the level of the mean-field treatment, this can be implemented as on the mean-field Hamiltonian.

function energy_on_twist(â, n̂; t, mu, ϕ, atol=1e-8)
    BHMtwist(ϕ) = psi -> BHM(â, n̂, t=t*cos(ϕ), mu=mu, psi=psi)

    state, psi = solve(â, n̂, BHMtwist(ϕ), atol=atol)
    energy = state' * BHMtwist(ϕ)(psi) * state
    return energy
end

function superfluid_density(â, n̂; t, mu, ϵ=1e-8)
    # in principle since ϵ(-0) = ϵ(0), one could avoid re-computing the last term
    return (
        energy_on_twist(â, n̂, ϕ=ϵ, t=t, mu=mu) -
        2 * energy_on_twist(â, n̂, ϕ=0, t=t, mu=mu) +
        energy_on_twist(â, n̂, ϕ=(-ϵ), t=t, mu=mu)
    ) / ϵ^2
end

superfluid_density (generic function with 1 method)

Let us now check how the energy varies with the magnitude of the phase twist in each phase of the system.

let
    function plot_phase_twist_response(t, mu; nmax=5, twist_angles=range(-π/2, π/2, length=50))
        â, n̂ = mean_field_ops(nmax)
        state, psi = solve(â, n̂, t=t, mu=mu)
        Egs = state' * BHM(â, n̂, t=t, mu=mu, psi=psi) * state
        twist_energies = map(ϕ -> energy_on_twist(â, n̂, t=t, mu=mu, ϕ=ϕ), twist_angles)

        p1 = plot(twist_angles, twist_energies .- Egs, lab="", lw=3)
        plot!(xlabel="Phase twist", ylabel="E(ϕ) - E(0)", title="\nVariation of energy with phase twist")

        p2 = bar(0:(length(state)-1), state, lab="")
        plot!(xlabel="Particle number", ylabel="|Coefficient|^2", title="\nGround state distribution", ylims=(0, 1.05))

        phase = (twist_energies[10] ≈ twist_energies[1]) ? "Mott Insulator" : "Superfluid"

        plot(p1, p2, size=(1000, 400), framestyle=:box, margins=10Plots.mm, suptitle="        (t=$t | μ=$mu | $phase)", suptitlefontsize=2)
    end

    display(plot_phase_twist_response(0.01, 0.5))
    display(plot_phase_twist_response(0.3, 0.5))
end

We see that the energy does not vary with the phase twist in the Mott insulator phase, whereas it has a quadratic dependance in the superfluid phase. This corresponds exactly with our interpretation of the superfluid density (note that there is no linear dependance because there is no spontaneous breaking of time reversal symmetry, so we must have ). We can now compare the phase diagram plotted using the order parameter and the superfluid density .

The superfluid density drops to zero exactly in the Mott insulator lobes! Further, we note that the transition is continuous as one would expect since the superfluid density should slowly vanish as the depth of the optical lattice is increased.

A generic integrator interface

RK4 seems like a good place to start. We begin by defining a struct to hold the state of the integrator, (u, tspan), where u can be anything that implements similar and supports basic algebraic operations and broadcasting, and tspan is an AbstractRange specifying the time interval of problem. The remaining variables are dummies to avoid allocation in a hot loop.

abstract type AbstractIntegrator end

struct RK4Integrator{T,S} <: AbstractIntegrator
    # current solver state
    u::T
    tspan::S

    # intermediate variables
    k1::T
    k2::T
    k3::T
    k4::T
    tmp::T

    RK4Integrator(u, tspan) = new{typeof(u),typeof(tspan)}(
        u, tspan, similar(u), similar(u), similar(u), similar(u), similar(u)
    )
end

Every integrator is expected to implement a step! method that expects a function f! implementing the in-place derivative, and performs the actual time-stepping.

function step!(integrator::RK4Integrator, f!, t)
    (; u, tspan, k1, k2, k3, k4, tmp) = integrator
    dt = step(tspan)

    f!(k1, u, t)

    @. tmp = u + dt / 2 * k1
    f!(k2, tmp, t + dt / 2)

    @. tmp = u + dt / 2 * k2
    f!(k3, tmp, t + dt / 2)

    @. tmp = u + dt * k3
    f!(k4, tmp, t + dt)

    @. u += dt / 6 * (k1 + 2 * k2 + 2 * k3 + k4)
    return u
end

step! (generic function with 1 method)

Then, we require only one generic function that actually loops through the time-steps. Below we just implement a basic version, but there is nothing stopping us from being more sophisticated with adaptive algorithms as well.

function solve!(f!, u0, tspan; solver, (callback!)=(iter, integrator) -> nothing)
    integrator = solver(u0, tspan)

    for iter in eachindex(tspan)
        step!(integrator, f!, tspan[iter])
        callback!(iter, integrator)
    end
end

solve! (generic function with 1 method)

At this point, we introduce the notion of a callback as a mutating function that takes the input (iter, integrator)::(Integer, AbstractIntegrator) and is invoked at the end of every iteration. We will soon see that the callback can be utilized by the user to run custom logic within the integrator loop without ever having to touch the actual internals. In the meanwhile, we can now solve any ordinary differential equation with the RK4 method!

    function dfdt!(du, u, t)
        du[1] = -5. * u[1]
    end

    solve!(dfdt!, [5.], range(0., 1., length=100), solver = RK4Integrator)

Note that this function only provides access to the value of u at the last time-step, which is a bit weird since typically we would want the evolution of the state as a time-series. While this was an oversight on my part, it also provides a good opportunity to utilize callbacks to store custom data during the solver steps. In order to do this, we may simply create a callback function like so. (Note that it is strictly necessary to wrap the keyword argument callback! in parenthesis because there is an ambiguity in syntax due to a possible != otherwise.)

# we construct the callback inside another function to create a closure over `data` instead of leaving it as a global variable (which would degrade performance!)
function create_saving_callback()
    data = []
    saving_callback = (iter, integrator) -> push!(data, integrator.u[1])
    return data, saving_callback
end

data, saving_callback = create_saving_callback()
solve!(dfdt!, [5.], range(0., 1., length=100), solver = RK4Integrator, (callback!)=saving_callback)
plot(data)

This works perfectly fine and is exactly what one would (should?) do for personal code! However, this is not a very modular approach. If the goal is to build a package with an intuitive and flexible user-facing API, we can build upon this a lot more to account for common use-cases. Let us see a possible way to achieve this.

The callback struct

In order to define a generic interface, we first need to think about what the general use-case of callbacks would be. In the context of an integrator, we expect that callbacks will always have the specific form of evaluating whether a certain condition is met at the time of invocation, and if so, it performs a certain effect that may mutate the state of the integrator. For example, we may want to compute and save a certain quantity every iteration, or normalize the state whenever it deviates beyond a certain threshold, or apply a periodic perturbation every 10 iterations, etc. So, we define a Callback struct as a collection of two callables; (1) condition with signature (iter, integrator) -> bool and (2) effect with signature (iter, integrator) -> integrator, although it can be mutating as well.

begin
    struct Callback{C,E}
        "condition for performing callback: (iter, integrator) -> bool"
        condition::C
        "callback function acting on solver state: (iter, integrator) -> integrator"
        effect::E
    end
    
    function (p::Callback)(iter, integrator)
        if p.condition(iter, integrator)
            p.effect(iter, integrator)
        end
    
        return integrator
    end
end

We can further define a CallbackList that sequentially invokes its elements if we have more than one callback.

begin
    struct CallbackList
        callbacks::Vector{Callback}
    end

    function (p::CallbackList)(iter, integrator)
        for callback in p.callbacks
            callback(iter, integrator)
        end

        return integrator
    end

    Base.getindex(p::CallbackList, idx) = getindex(p.callbacks, idx)
    Base.length(p::CallbackList) = length(p.callbacks)
end

Some common conditions and effects

Now that the basic structure is in place, let us implement some conditions that may be required quite often. Again, these don’t have to be structs, but since the specific use-cases here require statefulness, they are an appropriate choice. Note that we have not placed explicit safegaurds to statically check whether the function call has the right signature, so the program would fail at run-time if the signature does not match what is expected.

begin
    # trigger every n iterations
    mutable struct OnIterElapsed
        "number of iterations between trigger"
        save_freq::Int

        loop::Bool # if true, continuously fires, otherwise it is a one-shot condition
        flag::Bool # true if condition has been fired once

        OnIterElapsed(save_freq, loop=true) = new(save_freq, loop, false)
    end

    function (p::OnIterElapsed)(iter, integrator)
        res = iszero(iter % p.save_freq)
        return p.loop ? res : (!p.flag ? (p.flag = res; p.flag) : false)
    end

    # maybe for saving data to file as a backup during long program runs
    mutable struct OnRealTimeElapsed
        "starting time in seconds"
        start_tick::Float64
        "number of seconds between trigger"
        save_freq::Float64

        # :s - second, :m - minute, :h - hour
        function OnRealTimeElapsed(freq, unit=:m)
            if unit == :m
                freq *= 60
            elseif unit == :h
                freq *= 3600
            elseif unit != :s
                throw(ArgumentError("invalid unit `:$unit`, expected `:s`, `:m` or `:h`"))
            end

            new(time(), freq)
        end
    end

    # only gets called AFTER an iteration is complete!
    (p::OnRealTimeElapsed)(iter, state, H, envs) = ((time() - p.start_tick) > p.save_freq) ? (p.start_tick = time(); true) : false
end

We now define a generic effect that simply computes some specified observables using the integrator state. We do so by defining a struct RecordObservable which expects an input recipe which is a named tuple containing a collection of (observable_name = function_to_compute_observable). For example; (norm = (iter, integrator) -> norm(integrator.u), iter = (iter, integrator) -> iter). It then stores the result in data whenever the condition of its parent Callback returns true. While this is a trivial example, it may be quite useful if there is some non-trivial internal integrator state that must be tracked.

begin
    struct RecordObservable{D,O}
        "collection of string-array pairs containing observable data"
        data::D
        "functions to compute observable data"
        observables::O

        function RecordObservable(recipe)
            names = keys(recipe)
            observables = values(recipe)
            data = NamedTuple{names}(([] for _ in eachindex(names)))
            return new{typeof(data),typeof(observables)}(data, observables)
        end
    end

    # to access the data without an extra .data; bit iffy, but functional
    function Base.getproperty(p::RecordObservable, key::Symbol)
        if key in fieldnames(typeof(p))
            return getfield(p, key)
        else
            return getproperty(p.data, key)
        end
    end

    Base.length(p::RecordObservable) = length(p.data)

    function (p::RecordObservable)(iter, integrator)
        for i in 1:length(p)
            push!(p.data[i], p.observables[i](iter, integrator))
        end

        return integrator
    end
end

Having done this, we can now once again visualize the solution as a time-series at every iteration.

let
    record_state = Callback(
        OnIterElapsed(1),
        RecordObservable((u=(iter, integrator) -> integrator.u[1],))
    )
    solve!(dfdt!, [5.0], range(0.0, 1.0, length=100), solver=RK4Integrator, (callback!)=record_state)
    plot(record_state.effect.u)
end

Perfect! While it may seem that we introduced a ton of machinery for no reason, we have effectively removed the boilerplate for common tasks such as the condition-effect structure and data saving. The work we put into this allows us to write clean and intuitive code when we want to do more things within a callback. Perhaps a realistic use-case is to specify dynamical conditions that kick in at some intermediate time, for example, a random kick every n iterations. We could also constrain the solution from going below a certain threshold.

let
    record_state = Callback(
        OnIterElapsed(1),
        RecordObservable((u=(iter, integrator) -> integrator.u[1],))
    )

    hardwall_callback = Callback(
        (iter, integrator) -> integrator.u[1] < 1.,
        (iter, integrator) -> integrator.u[1] = 1.,
    )

    kick_callback = Callback(
        OnIterElapsed(30),
        (iter, integrator) -> integrator.u[1] += rand(),
    )

    solve!(dfdt!, [5.0], range(0.0, 1.0, length=100), solver=RK4Integrator, (callback!)=CallbackList([record_state, hardwall_callback, kick_callback]))
    plot(record_state.effect.u, ylims = [0., 5.1])
end

I think this is quite a nice example demonstrating how the callback pattern allows modularity and extensibility for the user with no need to poke into the internals of the core solver loop. However, it should be noted that design patterns such as this one tend to quickly ramp up in complexity and the overhead introduced both in compilation time and developer maintanence time can often outweigh its usefulness. So its important to keep your specific use-case in mind and try to use such constructions only when strictly required.

Before we conclude, it is important to note that the example presented above is a fairly specific utilization of callbacks in the context of scientific software where one may want to inject custom logic inside a core program loop. On the other hand, the concept is also widely prevalent in video game programming and web development, typically presenting itself in the context of asynchronous programming. While the key idea still remains that the invocation of a function is deferred until some other function is completed, the resulting interfaces may take up a different form than we see here. Perhaps that is a topic for another time.

Constructing the indexing scheme

The modes are labelled by two numbers , both of which are non-negative integers. A natural ordering scheme presents itself in the form of increasing energy eigenvalues, however the spectrum is fairly degenerate since . This degeneracy actually lets us come up with a scheme quite easily.

We can break down the scheme into two pieces; (1) identify the degeneracy level, (2) identify the location within the level. We know that a mode must belong to a level with degeneracy . This means that the number of elements in the lower energy levels is given by:

Within the level, itself provides a natural way of ordering the modes. We can thus write a linear indexing scheme like so:

Of course, we could equivalently use instead.

Although it is not readily apparent due to the quadratic nature of this mapping, we expect that it is invertible by construction. In such a case, we have effectively constructed a bijection from the natural numbers to a pair of natural numbers. In fact, what we have here is Cantor’s pairing function, which is the only bijective quadratic function on . The existence of this function shows that 2-tuples of natural numbers are countable! By extension, we can easily show that the set of rational numbers are countable as well.

While its not too surprising that this result is well-known and has ties to number theory, I found it really nice that it naturally popped up as a practical solution to a seemingly unrelated logistical problem involving the numerical implementation of exact diagonalization.

Automating the cropping

I have not spent too much time to figure out exactly why the solution works, so I simply outline the procedure here and discuss how we stumbled upon it. I should note here that what follows was largely borne out of discussions with Dhruva Sambrani.

Before proceeding, we assume that there is only a single point of interest and it is roughly a single-peaked intensity distribution. Finding the point of interest (i.e., the signal peak) is usually not too hard since one may use boxed-averages or some other sophisticated algorithm (there is an excellent stack exchange thread on this) to locate regions of interest where the intensity peaks. Obtaining a measure of the spread of the spot is a bit harder though. Ideally the signal is equipped with a standard deviation as it is a gaussian beam, but we cannot perform a linear regression to fit it to this model and extract the parameter as such (the whole point is to reduce the size of the image before doing these things). One may also just compute using the discrete data, with being the pixel co-ordinates. But in higher dimensions, this would require performing independant calculations across multiple cross-sections (either horizontal/vertical or radially outwards) and averaging those out, but we are lazy programmers trying to find the path of least action. So we instead look for some simpler qualitative measure that approximately gives us the spread.

The rough idea is as follows; we expect that the standard deviation of the intensity values around the peak of the beam should hold the information of the signal spread (there is likely a direct relation here). This is simple to compute; where is the mean intensity within the area. However, we do not know how large an area around the peak must be considered to compute this deviation.

In order to facilitate the exploration of this concept, we first write a small function to extract the indices corresponding to a (hyper-cube) of length 2 * window centered around the point anchor. All the code in this post is written to be applicable regardless of the dimensionality of the data.

function cube(anchor, window)
    return [
        rmin:rmax for (rmin, rmax) in
        zip(anchor .- window, anchor .+ window)
    ]
end

cube (generic function with 1 method)

We then define the measure of the extent of the signal as the standard deviation of the intensity values in a cube of pixels centered around the signal peak.

measure_extent(data, anchor, window) = std(data[cube(anchor, window)...])

measure_extent (generic function with 1 method)

The qualitative value of the signal spread is determined by computing the above measure over a range of (hyper-)cube sizes around the signal peak, and finding the point where it is maximum. Since this is only a qualitative value, we still require a hand-tuned parameter scale to adjust the final result.

# extract (hyper-)cubical ranges for cropping; f - measure of extent
function crop_extents(data; scale=5, max_window=200, f=measure_extent)
    anchor = Tuple(argmax(data)) # replace with robust peak finding algorithm   
    extent = argmax([f(data, anchor, window) for window in 1:max_window])

    return cube(anchor, extent * scale)
end

crop_extents (generic function with 1 method)

The biggest assumption here is that the standard deviation curve peaks at some non-zero value of the window size. We see that this is indeed the case for a unimodal distribution using some generated 1D data.

let
    gaussian1D(x, A, x0, sig) = A * exp(-(x - x0)^2 / (2 * sig^2))
    x = -50:0.1:50
    y = gaussian1D.(x, 1, 20, 1)
    yerr = 0.5 * rand(length(x))

    anchor, anchorerr = argmax(y), argmax(y .+ yerr)
    windows = 1:170
    rng = [measure_extent(y, anchor, window) for window in windows]
    rngerr = [measure_extent(y .+ yerr, anchor, window) for window in windows]

    plot(windows, rng, lab="Clean signal", lw=2, c=1)
    plot!(windows, rngerr, lab="Noisy signal", lw=2, c=2)
    vline!([argmax(rng)], c=1, lab="", ls=:dash, alpha=0.75)
    vline!([argmax(rngerr)], c=2, lab="", ls=:dash, alpha=0.75)

    plot!(legend=:bottomright, xlabel="Independant variable", ylabel="Measure of signal spread")
end

The boxed standard deviation measure seems to monotonically increase upto a maximum value and then continues to monotonically decrease. The window size which achieves the maximum value of this measure gives us a qualitative correspondence to the extent of the signal. We simply extract this value and use an appropriate multiplier to crop the data as required.

Some caveats with this method seems to be that:

1. high sensitivity to estimated location of the peak of the signal, i.e, the anchor.

2. the signal must have minimal overlap with other signals, and roughly symmetric spread (i.e., gaussian-like, without long tails) to ensure optimal performance.

For what came out of a quick text conversation with a friend, this was a pretty interesting find!

The Bose-Hubbard model

Let us consider a really simple system for demonstrating this; the 1D Bose-Hubbard model which describes interacting bosons in an optical lattice. What follows is largely based on things I worked on during my master’s thesis, so I will skip some details that can be found there. The Hamiltonian for the system is given as follows:

where / are bosonic creation/annihilation operators satisfying the canonical commutation relations . The system is governed by three parameters; - the hopping strength which controls tunneling between sites, - the repulsive interaction between atoms on the same site, and - the chemical potential, determining the number of atoms in the system. We may consider all quantities in units of , reducing our parameter space to .

Examining the limiting cases of Hamiltonian, we can get an idea of the possible ground state phases of the system. In the limit of , the system tends to localize into the lattice sites, resulting in a Mott-insulator phase which is incompressible and has fixed particle number per site. On the other hand, for the ground state is a completely delocalized state of atoms condensed into the lowest Bloch mode. One may then expect some kind of a Bose-Einstein condensate phase that has a coherent superposition of Fock states on each lattice site. We then expect that the global symmetry is broken, allowing us to use as an order parameter for this phase.

(*Strictly speaking, what we have is a superfluid phase since a true BEC may not occur in 1D at any temperature. However, in what follows we will work in the mean-field limit where we explicitly break the symmetry anyways. Within this approximation, we effectively do have a BEC precisely whenever the system exhibits superfluidity, even though the true many-body state may not spontaneously break the symmetry. I will elaborate on this in a future post.)

A mean-field analysis

While we could proceed with a full many-body simulation, perhaps using matrix product states, the point can be made just at the level of a mean-field. Note that from a physics standpoint, the mean-field approach is absolutely terrible in 1 dimension as it ignores quantum fluctuations which are dominant in lower dimensions. As such, the rest of this post should be treated as an overview of numerical trickeries involved rather than a truthful display of the nature of the phase transition of the full many-body system.

The mean field approach proceeds as follows: (1) we first decompose the creation operator in terms of its expectation value with the ground state, (which is also the order parameter), and a small fluctuation, such that , and then (2) ignore contributions to the Hamiltonian. Assuming that we work in the thermodynamic limit of a translationally invariant system, we reduce the problem to solving a single-site Hamiltonian (which is the same for every site by virtual of translation invariance);

We see that this is now a set of self-consistent equations and we need to find the fixed point of (Diagonalize and compute ) in order to extract the order parameter for the ground state.

A naive phase diagram

We will solve this self-consistent system using the most naive technique; fixed-point iteration. Basically, we begin with some initial guess and compute repeatedly until convergence is achieved. It is important to note that the function must satisfy certain constraints in order to guarantee convergence regardless of the initial guess. While I do not know of a mathematical proof for this particular system, numerically it seems that it does indeed converge (although this is no longer true if nearest neighbour interactions are introduced in the system).

# cutoff necessary since bosonic space is infinite dimensional
mean_field_ops(nmax) = (diagm(1 => sqrt.(1:nmax)), diagm(0 => 0:nmax))

BHM(â, n̂; t, mu, psi, U=1.0) = -mu * n̂ + 0.5 * U * n̂ * (n̂ - I) - 2t * psi * (â + â') + 2t * psi^2 * I

function solve(â, n̂, H; atol=1e-8, callback=identity)
    # initial guess
    state = rand(eltype(â), size(â, 1))
    psi = state' * â * state
    psi_old = psi

    while true
        ## f(psi)
        state = eigvecs(H(psi))[:, 1]
        state ./= sqrt(norm(state))
        psi = state' * â * state
        ##

        # check convergence
        (norm(psi - psi_old) < atol) && break
        psi_old = psi

        # for injecting other custom logic later on; by default it does nothing
        callback(psi)
    end

    return state, psi
end

solve(â, n̂; t, mu, atol=1e-8) = solve(â, n̂, psi -> BHM(â, n̂, t=t, mu=mu, psi=psi), atol=atol)

solve (generic function with 2 methods)

We can now plot a naive phase diagram by simply looping over a grid of parameter values and visualizing the magnitude of the order parameter.

begin
    â, n̂ = mean_field_ops(4)
    npoints = 50
    ts = range(0.0, 0.12, npoints)
    mus = range(0.0, 3.0, npoints)
    res = zeros(length(mus), length(ts))

    # can be multi-threaded since each computation is entirely independant from the others
    Threads.@threads for idx in CartesianIndices(res)
        H = psi -> BHM(â, n̂, t=ts[idx.I[2]], mu=mus[idx.I[1]], psi=psi)
        _, res[idx] = solve(â, n̂, H)
    end

    heatmap(ts, mus, res)
end

As expected, there are Mott insulator lobes where the order parameter vanishes and there is a second order transition to the superfluid phase where symmetry is broken. However, if all we’re interested in is the phase boundary and not the actual value of the order parameter, we can do much better.

Since we know that what we’re looking for is a fixed point, we might expect that simply checking whether would immediately tell us if we’re in the Mott insulator regime without having to go through the iterative procedure. However, it turns out that is always a fixed point of the system; it is simply an unstable one when the system is in the superfluid regime. Perhaps we can still salvage this line of thinking. Let us check the actual convergence of the order parameter for some parameter values to get a better idea of whats going on:

# callback to record data on every iteration
struct RecordObservable{T}
    data::Vector{T}
end

(o::RecordObservable)(psi) = push!(o.data, psi)

function convergence_plot(t, mu; n=7, xlims)
    p = plot(framestyle=:box, ylabel="Order parameter", xlabel="Number of iterations", title="\n(t=$t | mu=$mu)", legend=:topright, xlims=xlims)

    history = RecordObservable(Float64[])

    for _ in 1:n
        history = RecordObservable(Float64[])
        solve(â, n̂, psi -> BHM(â, n̂, t=t, mu=mu, psi=psi), callback=history)
        plot!(history.data, lab="", ls=:dashdot, lw=1.5)
    end

    hline!([history.data[end]], c=:black, lw=2, alpha=0.75, lab="Converged value")

    return p
end

display(plot(convergence_plot(0.06, 0.5, xlims=[1, 20]), convergence_plot(0.1, 0.5, xlims=[1, 20]), size=(1000, 400), margins=10Plots.mm))

We see that the convergence proceeds strictly monotonically towards the stable fixed point. This means that all we need to do is begin with and check whether it increases or decreases in a single iteration to determine whether the system is a Mott insulator or a superfluid. The accuracy of the phase boundary is then of course limited by how small we choose . Using this technique, we can plot the phase diagram much faster.

function isSuperfluid(H; psi=1e-8)
    ## f(psi)
    state = eigvecs(H(psi))[:, 1]
    state ./= sqrt(norm(state))
    return (state' * â * state) > psi
end

res = zeros(length(mus), length(ts))

Threads.@threads for idx in CartesianIndices(res)
    H = psi -> BHM(â, n̂, t=ts[idx.I[2]], mu=mus[idx.I[1]], psi=psi)
    res[idx] = isSuperfluid(H)
end

heatmap(ts, mus, res)

This is already great, but we can do even better. Notice how for a given value of , there is exactly one point where the order parameter jumps from 0 to a finite value. This means that we can precisely find the point of transition by simply using the bisection method along for each , giving us a phase boundary of high precision for very little computational work (the error drops as for bisections).

function bisection(f, low, high; atol=1e-8)
    mid = 0

    while !isapprox(low, high, atol=atol)
        mid = (low + high) / 2

        if f(mid)
            low = mid
        else
            high = mid
        end
    end

    return mid
end

mus = range(0.0, 3.0, length=100)
ts = zeros(size(mus))
Threads.@threads for idx in eachindex(mus)
    ts[idx] = bisection(t -> !isSuperfluid(psi -> BHM(â, n̂, t=t, mu=mus[idx], psi=psi)), 0.0, 0.1)
end

plot(ts, mus, legend=:topright, lw=2, c=:black, lab="")
scatter!(ts, mus, c=:black, lab="", xlims=[0, 0.12])

To obtain a boundary of similar resolution by solving for the ground state in an entire grid of parameter values would be several orders of magnitude slower and wasteful in terms of the information that we actually utilize. Of course, there are tons of information in the actual ground state such as the correlations in the system that provide more insight into the nature of the phase transition, but these are not required if all we want is a boundary. Such a scheme would still work if there are more than two phases although more book-keeping may be involved to find a combination of order parameters to serve as a binary quantity to identify each regime.

Finally, we note that obviously the observations involved here were specific to the fact that the mean-field approach resulted in a self-consistent set of equations. Furthermore, if the phase boundary gets more complex, for example, with two jumps in for a given , as in the true 1D phase diagram, using the bisection method may also prove a bit harder. So I suppose the goal of this post was not to provide a one-size-fits-all solution, but rather to display some general ideas that could be adapted or serve as inspiration to simplify the determination of phase boundaries for other systems/numerical methods.