%run ../code/init_mooc_nb.ipy

# Since the number of physical parameters we need to simulate is ever growing,
# we're going to use a different way to provide parameters, that doesn't
# require reconstructing the system. Take a look at how `par` is used below.
# Basically we first define the functions, and fill in the values only afterwards.

def plot_1D_f(sys, f, n, ax=None):
    """Plot 1D function calculated from a Kwant system."""
    x = [sys.site(i).pos[0] for i in range(sys.graph.num_nodes)]
    x = np.array(x)
    indx = np.argsort(x)
   
    if ax is None:
        fig = plt.figure()
        ax = plt.subplot(1, 1, 1)
    ax.plot(x[indx], f[indx], '-')
    return ax


def ts_modulated_wire(L=50):
    """Create an infinite wire with a periodic potential
    
    Chain lattice, one orbital per site.
    Returns finalized kwant system.
    
    Arguments required in onsite/hoppings: 
        t, mu, mu_lead, A, phase
    
    The period of the potential is 2*pi/L.
    """
    omega = 2 * np.pi / L
    def onsite(site, par):
        x = site.pos[0]
        return 2*par.t - par.mu + par.A * (np.cos(omega * x + par.phase) + 1)
    
    def hopping(target, source, par):
        return -par.t
    
    sym_lead = kwant.TranslationalSymmetry([-L])
    
    lat = kwant.lattice.chain()
    sys = kwant.Builder(sym_lead)
       
    sys[(lat(x) for x in range(L))] = onsite
    sys[lat.neighbors()] = hopping
    
    return sys.finalized()


def modulated_wire(L=50, dL=10):
    """Create a pump. 
    
    Chain lattice, one orbital per site.
    Returns finalized kwant system.
    
    L is the length of the pump,
    dL is the length of the clean regions next to the pump,
            useful for demonstration purposes.
    
    Arguments required in onsite/hoppings: 
        t, mu, mu_lead, A, omega, phase
    """
    def onsite(site, par):
        x = site.pos[0]
        
        return 2*par.t - par.mu + par.A * (np.cos(par.omega * x + par.phase) + 1)
    
    lead_onsite = lambda site, par: 2*par.t - par.mu_lead
    
    def hopping(target, source, par):
        return -par.t
    
    lat = kwant.lattice.chain()
    sys = kwant.Builder()
    
    sys[(lat(x) for x in range(L))] = onsite
    sys[lat.neighbors()] = hopping
    
    sym_lead = kwant.TranslationalSymmetry([-1])
    lead = kwant.Builder(sym_lead)
    
    lead[lat(0)] = lead_onsite
    lead[lat.neighbors()] = hopping
    
    sys.attach_lead(lead)
    sys.attach_lead(lead.reversed())
    
    return sys.finalized()


def total_charge(value_array):
    """Calculate the pumped charge from the list of reflection matrices."""
    determinants = [np.linalg.det(r) for r in value_array]
    charge = np.cumsum(np.angle(np.roll(determinants, -1) / determinants))
    charge = charge - charge[0]
    return charge / (2*np.pi)

ERROR: File `u'../code/init_mooc_nb.ipy.py'` not found.

Thouless pumps¶

Dganit Meiden from Ben Gurion University will introduce Thouless pumps,.

MoocVideo("gKZK9IGY9wo", src_location='3.1-intro')

Hamiltonians with parameters¶

Previously, when studying topology of systems supporting Majoranas (both the Kitaev chain and the nanowire), we were able to calculate topological properties from studying the bulk Hamiltonian $H(k)$.

There are two points of view on this Hamiltonian. We could either consider it a Hamiltonian of an infinite system with momentum conservation

$$H = H(k) |k\rangle\langle k|$$

or we could equivalently say that we study a finite system with only a small number of degrees of freedom (corresponding to a single unit cell), and a Hamiltonian depending on a continuous periodic parameter $k$.

Of course without specifying that $k$ is the real space momentum, there is no meaning in bulk-edge correspondence (since the edge is an edge in real space), but the topological properties are still well-defined.

The need to study a Hamiltonian with external parameters arises when we want to know what happens if we slowly change parameters of a system, so that

$$H = H(t)$$

The slow adiabatical change of parameters ensures that if the system was initially in the ground state, it will stay in the ground state, so that the topological properties are useful.

A further requirement for topology to be useful is the periodicity of time evolution:

$$H(t) = H(t+T).$$

The period can even go to $\infty$, in which case $H(-\infty) = H(+\infty)$. The reasons for the requirement of periodicity are somewhat abstract. If the Hamiltonian has parameters, we're studying topology of a mapping from the space of parameter values to the space of all possible gapped Hamiltonians. This mapping has nontrivial topological properties only if the space of parameter values is compact.

For us this once again means that the Hamiltonian has to be periodic in time.

Of course, if we want systems with bulk-edge correspondence, then in addition to $t$ our Hamiltonian must still depend on the real space coordinate, or the momentum $k$.

Quantum pumps¶

On the image below (source: Chambers's Encyclopedia, 1875, via Wikipedia) you see a very simple periodic time-dependent system, an Archimedes screw pump.

The changes to the system are clearly periodic, and the pump works the same no matter how slowly we change the parameters, so it is an adiabatic tool.

What about a quantum analog of this pump? Turns out it is just as simple as you would think.

Let's take a one-dimensional region, coupled to two electrodes on both sides, and apply a strong sine-shaped confining potential in this region. As we move the confining potential, we will be dragging electrons captured in it.

So our system now looks like this

# Plot of the potential in the pumping system as a function of coordinate.
# Some part of the leads is shown with a constant potential.
# Regions with E < 0 should be shaded to emulate Fermi sea.
A=0.6
L=10
lamb=(10/5.3)/(2*np.pi)
mu = -0.4
mu_lead=-0.8

def f(x):
    if x < 0.0:
        return mu_lead
    if x >= 0.0 and x <= L:
        return mu + A * (1.0 - np.cos(x/lamb))
    if x > L:
        return mu_lead

x = np.linspace(-5,15,1000)
y = [f(i) for i in x]

plt.figure(figsize=(6,4))
plt.plot(x,y, 'k', lw=1.2)
plt.xlim(-2.5,12.5)
plt.ylim(-2,2)



# x_fill = []
# y_fill = []
# for x,y in zip(x,y):
#     if y < 0:
#         x_fill.append(x)
#         y_fill.append(y)

# plt.fill_between(x_fill, y_fill, 0, color='r', alpha=0.5)

y = [i if i <= 0 else 0 for i in y]
plt.fill_between(x, y, 0, color='r', where=np.array(y) < 0.0, alpha=0.5, edgecolor='k', lw='1.5')

# plt.plot([-5,15],[0,0], 'k-', lw=1.5);
plt.arrow(2.0, 1.25 , 5 , 0, head_width=0.15, head_length=1.0, fc='k', ec='k');

plt.xlabel('$x$');
plt.ylabel('$U(x)$');
plt.xticks([]);
plt.yticks([]);

It is described by the Hamiltonian

$$H(t) = \frac{k^2}{2m} + A [1 - \cos(x/\lambda + 2\pi t/T)].$$

As we agreed, we change $t$ very slowly, so that our answer won't depend on the speed of changing $t$.

When $A \gg 1 /m \lambda^2$ the confining potential is strong, and if additionally if the chemical potential $\mu \ll A$, the states bound in each minimum of the potential are only overlapping very weakly.

We can approximate the potential near the bottom of each well as quadratic making the Hamiltonian that of a simple Harmonic oscillator. This gives us discrete levels of the electrons with energies $E_n = (n + \tfrac{1}{2})\omega_c$, with $\omega_c = \sqrt{A/m\lambda^2}$ the oscillator frequency.

We can quickly check how continuous bands in the wire become discrete evenly spaced bands as we increase $A$:

def plot_modulate_wire_dispersion(A=0.0):
    L   = 17
    par = SimpleNamespace(t=1, mu=0.0, A=A, phase=0.0)
    
    sys = ts_modulated_wire(L)
    
    fig, ax = plt.subplots()
    
    ax.set_color_cycle(['k'])
    ax.set_ylim(-.2,1.3)
    
    plt.title("Band structure, $A = %3.1f$" % par.A)
    
    plt.xticks([-np.pi, 0.0, np.pi], ['$-\pi$', '$0$', '$\pi$'])
    plt.yticks([0, 0.5, 1.0])
    
    plt.xlabel('$k$')
    plt.ylabel('$E$')
    kwant.plotter.bands(sys, momenta=201, args=[par], ax=ax)
    
    return fig

StaticInteract(lambda A: plot_modulate_wire_dispersion(A*0.2),
               A = RangeWidget(0, 4))

So unless $\mu = E_n$ for some $n$, each minimum of the potential well contains an integer number of electrons $N$.

The electron wave functions from the neighboring potential wells do not overlap, therefore when we move the potential by one period, we move exactly $N$ electrons.

question = "Why are some levels in the band structure flat and some aren't?"
answers = ["The flat levels are the ones whose energies are not sensitive to the offset of confining potential.",
           "Destructive interference of the wave functions in the neighboring minima supresses the dispersion.",
           "The flat levels are localized deep in the potential minima, "
           "so the bandwidth is exponentially small.",
           "The flat levels correspond to the filled states, and the rest to empty states."]
explanation = ("The dispersion of the bands in a perodic potential appears "
               "when the wave functions from the neighboring minima overlap.")

MoocMultipleChoiceAssessment(question=question, answers=answers, correct_answer=2, explanation=explanation)

Quantization of pumped charge¶

As we already learned, integers are important, and they could indicate that something topological is happening.

At this point we should ask these questions: Is the number of electrons $N$ pumped per cycle topological, or can we pump any continuous amount of charge? How important is it that the potential well is deep?

Thought experiment

To simplify the counting let's "dry out" the pump: We can define a procedure that empties the middle region, and pushes $n_L$ extra electrons to the left and $n_R$ electrons to the right.

For example, we can do this:

# Same plot as above, but now with an extra rectangular barrier in the 
# middle, and with arrows both ways showing that the barrier widens.

# Plot of the potential in the pumping system as a function of coordinate.
# Some part of the leads is shown with a constant potential.
# Regions with E < 0 should be shaded to emulate Fermi sea.

# Plot of the potential in the pumping system as a function of coordinate.
# Some part of the leads is shown with a constant potential.
# Regions with E < 0 should be shaded to emulate Fermi sea.
A=0.6
L=10
lamb=(10/5.3)/(2*np.pi)
mu = -0.4
mu_lead=-0.8
a   = 4.5
b   = 6.5
top = 1.2

def f(x):
    if x < 0.0:
        return mu_lead
    if x >= 0.0 and x <= a:
        return mu + A * (1.0 - np.cos(x/lamb))
    if x > a and x < b:
        return top
    if x >= b and x <= L:
        return mu + A * (1.0 - np.cos(x/lamb))
    if x > L:
        return mu_lead


x = np.linspace(-5,15,1000)
y = [f(i) for i in x]

plt.figure(figsize=(6,4))
plt.plot(x,y, 'k', lw=1.2)
plt.xlim(-2.5,12.5)
plt.ylim(-2,2)



# x_fill = []
# y_fill = []
# for x,y in zip(x,y):
#     if y < 0:
#         x_fill.append(x)
#         y_fill.append(y)

# plt.fill_between(x_fill, y_fill, 0, color='r', alpha=0.5)

y = [i if i <= 0 else 0 for i in y]
plt.fill_between(x, y, 0, color='r', where=np.array(y) < 0.0, alpha=0.5, edgecolor='k', lw='1.5')

plt.arrow(a, 1.05 , -1 , 0, head_width=0.1, head_length=0.4, fc='k', ec='k');
plt.arrow(b, 1.05 , +1 , 0, head_width=0.1, head_length=0.4, fc='k', ec='k');

plt.xlabel('$x$');
plt.ylabel('$U(x)$');
plt.xticks([]);
plt.yticks([]);

A reverse of this procedure does the reverse of course, so it reduces the number of charges on the left and the right sides.

Now here comes the trick:

When the middle region is emptied, the two sides are completely disconnected, and so the number of electrons on either side must be integer for every eigenstate of the Hamiltonian.
Next, if we performed the manipulation adiabatically, then if we start in an eigenstate of the Hamiltonian, we will also end in an eigenstate of the Hamiltonian.
Adding 1. and 2. together with the procedure of drying the middle out, we conclude that we pumped an exact integer number of charges.
Finally, the adabatic manipulation is only possible if the Hamiltonian stays gapped at all times.

Bonus: In our argument we didn't use the shape or the strength of the potential, so it applies universally to any possible pump.

So without doing any calculation we are able to conclude that:

The number of electrons pumped per cycle of a quantum pump is an integer as long as the bulk of the pump is gapped. Therefore it is a topological invariant.

Counting electrons through reflection.¶

The expression for the pumped charge in terms of the bulk Hamiltonian $H(k, t)$ is complicated.

It's an integral over both $k$ and $t$, called a Chern number or in other sources a TKNN integer. Its complexity is beyond the scope of our course, but is extremely important, so we will have to study it... next week.

There is a much simpler way to calculate the same quantity by using scattering formalism. From the previous two weeks you should remember that presence or absence of Majoranas at an end of the system can be calculated both as $Q = \textrm{sign}[\textrm{Pf}\,H(0)\,\textrm{Pf}\,H(\pi)]$, and as $Q=\textrm{sign}\det r$, where $r$ is the reflection matrix from one end of the Majorana wire.

In order to derive the scattering expression, we need to understand how does pumped charge manifest in reflection matrix.

Let's start from the case when there's just one mode in the reservoir. We'll count the charge pumped by making the reservoir finite although very large.

Now all the levels in the reservoir are quantized, and are standing waves, so they are equal weight superpositions of the waves going to the left $\psi_L$ and to the right $\psi_R$:

$$ \psi_n = \psi_L(x) + \psi_R(x) \propto \exp(ik_n x) + \exp(-ik_n x + \phi), $$

of course the wave momentum $k_n$ is a function of energy. The relative phase shift $\phi$ is necessary to satisfy the boundary condition at $x=0$, where $\psi_L = r \psi_R$, so $\exp(i \phi) = r$. The energies of the levels are determined by requiring that the phases of $\psi_L$ and $\psi_R$ also match at $x = -L$.

Let's think what happens when we pump one extra charge into the reservoir. All the energy levels should shift by one up: $E_n \rightarrow E_{n+1}$, and accordingly the wave functions must also change $\psi_n \rightarrow \psi_{n+1}$.

We conclude that the charge can only be pumped as the reflection phase $\phi$ advances by $2\pi$.

It's very easy to generalize our argument to many modes. For that we just need to sum all of the reflection phase shifts, which means we need to look at the phase of $\det r$.

We conclude that there's a very compact relation between charge $dq$ pumped by an infinitesimal change of an external parameter and the change in reflection matrix $dr$:

$$ dq = \frac{r^\dagger dr }{ 2 \pi i}. $$

While we proved this relation only for the case when there is no transmission from the reservoir, and $r$ is a unitary matrix, written in this form it also holds if there is some transmission.

Let's check if this expression holds to our expectations. If $||r||=1$, this is just the number of times the phase of $\det r$ winds around zero, and it is certainly an integer, as we expected.

Applying the topological invariant¶

We're left with a simple exercise.

We know now how to calculate the pumped charge during one cycle, so let's just see how it works in practice.

The scattering problem in 1D is extremely quick to solve, so let's just calculate the pumped charge versus a function of chemical potential in the pump

def plot_charge(mu, ax):
    L = 100
    energy = 0.0
    par = SimpleNamespace(t=1, mu=mu, mu_lead=mu, A=0.6, omega= .3, phase=0.0)

    sys = modulated_wire(L)

    phases = np.linspace(0, 2*np.pi, 100)
    rs = []

    for par.phase in phases:
        smatrix = kwant.smatrix(sys, energy, args=[par])
        rs.append(smatrix.submatrix(0, 0))

    wn = -total_charge(rs)
    plt.plot(phases / (2 * np.pi), wn, '-', label='$\mu=%3.2f$' % mu)

fig = plt.figure(figsize=[9.5, 3.5])
ax = fig.add_subplot(1, 2, 2)
mu_vals = [0.1, 0.3, 0.6, 0.9]
for mu in mu_vals:
    plot_charge(mu, ax)
ax.set_xticks([0, 1])
ax.set_xticklabels(['$0$', '$1$'])
ax.set_xlabel('$t/T$')
ax.set_yticks(range(4))
ax.set_yticklabels(['${0}$'.format(i) for i in range(4)])
ax.set_ylabel('$q/e$')
ax.set_ylim([-.5, 3.5])
ax.set_title("Pumped charge")

ax2 = fig.add_subplot(1, 2, 1)
L   = 17
par = SimpleNamespace(t=1, mu=0.0, A=.6, phase=0.0)

sys = ts_modulated_wire(L)

ax2.set_color_cycle(['k'])
ax2.set_ylim(-.2,1.3)
ax2.set_xlim([-np.pi, np.pi])

ax2.set_title("Band structure, $A = %3.1f$" % par.A)

ax2.set_xticks([-np.pi, 0.0, np.pi])
ax2.set_xticklabels(['$-\pi$', '$0$', '$\pi$'])
ax2.set_yticks([0, 0.5, 1.0])

ax2.set_xlabel('$k$')
ax2.set_ylabel('$E$')
kwant.plotter.bands(sys, momenta=201, args=[par], ax=ax2)
ax2.hlines(y=mu_vals, xmin=-np.pi, xmax=np.pi, colors=['b', 'g', 'r', 'c'],
           linestyles='--');

In the left plot, we show the band structure, and the different colors correspond to different chemical potentials. The right plot shows the corresponding pumped charge. During the pumping cycle the charge may change, and the relation between the offset $\phi$ of the potential isn't always linear. However we see that after a full cycle, the pumped exactly matches the number of filled levels in a single potential well.

As a final mental exercise about pumps, let's think what happens if we disconnect the leads and consider the spectrum of a closed system.

As the periodic potential moves, it tries to increase the energies of all the states at the right of the system and reduce the energy of all the states to the left (that's what pumping does after all).

So there should be states crossing the bulk band gap. Let's see if it's true.

L = 110
energy = 0.0
par = SimpleNamespace(t=1, mu=0, mu_lead=0, A=0.6, omega= .3, phase=0.0)

sys = modulated_wire(L)

phases = np.linspace(0, 2*np.pi, 100)
en = []

for par.phase in phases:
    en.append(np.linalg.eigvalsh(sys.hamiltonian_submatrix(args=[par])))

fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.set_color_cycle(['k'])
ax.plot(phases / (2*np.pi), en)
ax.set_ylim([0, 1.2])

ax.set_xticks([0, 1])
ax.set_xticklabels(['$0$', '$1$'])
ax.set_xlabel('$t/T$')

ax.set_yticks([0, 0.5, 1])
ax.set_yticklabels(['$0$', '$0.5$', '$1$'])
ax.set_ylabel('$E$');

Indeed, the levels in the bulk stay flat and have a high degeneracy, but we see that there also are single levels that get pushed across the gap. Since bulk is homogeneous, these states have to be localized at the edge.

Of course, since we have a finite system, the charge cannot be pumped forever from one end into the other. So the pumping breaks down when you see the edge states crossing with the bulk bands. At these moments the charge can flow back through the bulk.

question = ("What happens to the dependence of the reflection phase shift on time if we "
            "remove one of the reservoirs and leave the other one?")
answers = ["It becomes constant.",
           "For most of the cycle it stays the same, but there appear "
           "sharp jumps such that the total winding becomes zero.",
           "Nothing changes, since the two ends of the pump are "
           "far apart from each other, and the pump is not conducting.",
           "The reflection phase gets a new time dependence with zero winding, unrelated to the original one."]
explanation = ("The total pumped charge must become equal to zero since there's nowhere to place the charge, but "
               "since the pump is insulating, the phase cannot change "
               "for most of the cycle unless a sharp resonance appears")

MoocMultipleChoiceAssessment(question=question, answers=answers, correct_answer=1, explanation=explanation)

Quantized charge and scattering invariant¶

MoocVideo("6lXRAZ7hv7E", src_location='3.1-summary')

Questions about what you learned? Ask them below

MoocDiscussion('Questions', 'Quantum pumps')

Table of Contents