{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Fermionic Quantization (and the Spin Statistics Theorem)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So far we've essentially discussed \"bosonic\" second quantization, where we assign a harmonic oscillator to each degree of freedom of some single particle Hilbert space, and the number operator of each oscillator keeps track of how many particles are in *that state*. It works out that this \"Fock space\" corresponds dimensionally to a tower of permutation symmetric tensor products of $0, 1, 2, 3, \\dots$ particles. In other words, the use of harmonic oscillators automatically imposes for us that condition that the second quantized particles be permutation symmetric. \n", "\n", "It's worth remember that although the creation and annihilation operators are not hermitian, they can be used as building blocks for hermitian operators. And if we have multiple oscillators, we can just tensor these creation and annihilation operators with identities so they act on the appropriate subspaces. \n", "\n", "For bosons, if we have multiple creation and annihilation operators, they should obey the following commutation relations:\n", "\n", "$$ [b_{i}, b_{j}] = [b^{\\dagger}_{i}, b^{\\dagger}_{j}] = 0 $$\n", "$$ [b_{i}, b^{\\dagger}_{j}] = \\delta^{i}_{j} $$\n", "\n", "Where \\\\( b^{\\dagger} \\\\) is a creation operator, \\\\( b \\\\) is an annihilation operator, and: the commutator is \\\\( [A, B] = AB - BA \\\\). \n", "\n", "In practice, if we work in finite dimensions, we can cap the maximum number of quanta in a given harmonic oscillator, and get finite dimensional \"creation\" and \"annihilation\" operators, which add and subtract quanta from each oscillator, although they don't satisfy perfectly the correct commutation relations. \n", "\n", "Okay, so here's the thing:\n", "\n", "If we want to second quantize fermionically, as opposed to bosonically, we have to make some changes. First, our oscillators can only have 0 or 1 excitations. In other words, at maximum only 1 fermion can be in a given state. This is the Pauli exclusion principle at work. The whole thing has to do with the fact while fermions and bosons are both \"indistinguishable\" (with respect to the tensor product) particles, fermions must always be in a permutation *antisymmetric* state, unlike bosons which must be in a permutation *symmetric* state. Look what happens if we try to antisymmetrize two identical states via $A, B \\rightarrow A \\otimes B - B \\otimes A$: $\\mid \\uparrow \\rangle \\mid \\uparrow \\rangle - \\mid \\uparrow \\rangle \\mid \\uparrow \\rangle = 0$: we get the zero vector. The Pauli exclusion principle is just a fancy way of saying that fermions, by nature, are permutation antisymmetric particles. If we permute them, then the whole tensor state is multiplied by -1. This just changes the overall phase, and not the probabilities: indeed, the particles are still indistinguishable, despite them all picking up a sign flip when they are swapped in the tensor product.\n", "\n", "For this reason, in terms of second quantization, it doesn't matter the order in which we create bosons, but it does matter for fermions: \\\\( f^{\\dagger}_{i} f^{\\dagger}_{j} \\mid 0 \\rangle = -f^{\\dagger}_{j} f^{\\dagger}_{i} \\mid 0 \\rangle \\\\), where \\\\( \\mid 0 \\rangle \\\\) is the fermion vacuum aka the state of all oscillators having 0 quanta.\n", "\n", "The upshot is that the commutation relations between fermions involve the anticommutator \\\\( \\{A, B\\} = AB + BA \\\\), instead of the commutator.\n", "\n", "$$ \\{f_{i}, f_{j}\\} = \\{f^{\\dagger}_{i}, f^{\\dagger}_{j}\\} = 0 $$\n", "$$ \\{f_{i}, f^{\\dagger}_{j}\\} = \\delta^{i}_{j} $$\n", "\n", "Luckily, with a trick, it's not hard to construct the right matrix representation for these operators. Indeed, it's kinda nice that the fermion excitations are capped at 1, since we can use $2$ x $2$ matrices for their creation and annihilation operators, and we can deal with a nice actually finite dimensional vector space. \n", "\n", "For example, suppose we have 5 fermions. The standard $2$ x $2$ matrices for creation and annihilation operators are just:\n", "\n", "$$ f^{\\dagger} = \\begin{pmatrix} 0 & 0 \\\\ 1 & 0 \\end{pmatrix} $$\n", "$$ f = \\begin{pmatrix} 0 & 1 \\\\ 0 & 0 \\end{pmatrix} $$\n", "\n", "But here's the catch: to get 5 annihilation operators with the correct commutation relations, preserving the antisymmetry of the fermions, we take:\n", "\n", "$$ f_{0} = f \\otimes I \\otimes I \\otimes I \\otimes I $$\n", "$$ f_{1} = Z \\otimes f \\otimes I \\otimes I \\otimes I $$\n", "$$ f_{2} = Z \\otimes Z \\otimes f \\otimes I \\otimes I $$\n", "$$ f_{3} = Z \\otimes Z \\otimes Z \\otimes f \\otimes I $$\n", "$$ f_{4} = Z \\otimes Z \\otimes Z \\otimes Z \\otimes f $$\n", "\n", "The idea is that there is a \"normal ordering\" for the fermions. When the operators are applied to the vacuum in the descending order, the $Z$'s in \\\\( f_{4} \\\\), don't matter since there are no excitations in those oscillators: we're in the vacuum after all. But when the operators are applied in the reverse order, they pick up a negative sign from the $Z$'s. You can check that this works:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import qutip as qt\n", "import numpy as np\n", "\n", "def anticommutator(a, b):\n", " return a*b + b*a\n", "\n", "#########################################################################################\n", "\n", "def fermion_operators(n):\n", " return [qt.tensor(*[qt.destroy(2) if i == j\\\n", " else (qt.sigmaz() if j < i\\\n", " else qt.identity(2))\\\n", " for j in range(n)])\\\n", " for i in range(n)]\n", "\n", "def test_fermion_operators(f):\n", " for i in range(len(f)):\n", " for j in range(len(f)):\n", " d = f[i].shape[0]\n", " test1 = anticommutator(f[i], f[j]).full()\n", " test2 = anticommutator(f[i], f[j].dag()).full()\n", " if not \\\n", " (np.isclose(test1, np.zeros((d,d))).all()\\\n", " and \\\n", " ((np.isclose(test2, np.zeros((d,d))).all() and i != j)\\\n", " or (np.isclose(test2, np.eye(d)).all() and i == j))):\n", " return False\n", " return True\n", "\n", "#########################################################################################\n", "\n", "n = 3\n", "IDn = qt.identity(2**n)\n", "IDn.dims = [[2]*n, [2]*n]\n", "\n", "f = fermion_operators(n)\n", "print(test_fermion_operators(f))\n", "\n", "N = sum([a.dag()*a for a in f]) # number operator\n", "I = qt.basis(2**n, 0) # vacuum state\n", "I.dims = [[2]*n, [1]*n]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Okay, so we have $n$ fermionic oscillators to play with. And we want to second quantize an $n$ dimensional single particle Hilbert space fermionically. So now we have to talk about what the tower of antisymmetric multi-particle states looks like.\n", "\n", "First, we observe that $sgn(\\sigma) = (-1)^{T(\\sigma)}$, where $\\sigma$ is some permutation: e.g., $132$ would be a permutation of $123$. $T(\\sigma)$ is the number of transpositions in the permutation. And $sgn(\\sigma)$ is known as the parity of the permutation.\n", "\n", "If we want to antisymmetrize a set of states, we basically want to sum over all permutations of the states, forming the tensor product of the pieces in each order, multiplying each tensor product by $-1$ for each swap in the permutation:\n", "\n", "$ \\sum_{\\sigma} (-1)^{T(\\sigma)} ( \\sigma_{i} \\otimes \\sigma_{j } \\otimes \\dots)$\n", "\n", "Using this, we can easily calculate the basis states for the permutation antisymmetric subspace of $n$ particles who each live in a $d$ dimensional Hilbert space.\n", "\n", "We take each set of the $d$ basis vectors, each set that has $n$ elements and contains no repeats, and antisymmeterize those basis vectors. We'll actually end up with $\\begin{pmatrix} d \\\\ n \\end{pmatrix}$ basis vectors. We can form a rectangular matrix out of them, which will let us translate between a state of $\\begin{pmatrix} d \\\\ n \\end{pmatrix}$ dimensions, and a state of $n$ antisymmeterized particle states. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import qutip as qt\n", "from qutip.qip.operations import swap\n", "import itertools\n", "\n", "def perm_parity(lst):\n", " parity = 1\n", " for i in range(0,len(lst)-1):\n", " if lst[i] != i:\n", " parity *= -1\n", " mn = min(range(i,len(lst)), key=lst.__getitem__)\n", " lst[i],lst[mn] = lst[mn],lst[i]\n", " return parity \n", "\n", "def antisymmetrize(*states):\n", " a = sum([perm_parity(list(perm))*qt.tensor(*[states[p] for p in perm])\\\n", " for perm in itertools.permutations(list(range(len(states))))])\n", " if a.norm() != 0:\n", " a = a.unit()\n", " return a\n", "\n", "def antisymmetric_basis(n, d=2):\n", " states = []\n", " for perm in itertools.combinations_with_replacement(list(range(d)), r=n):\n", " a = antisymmetrize(*[qt.basis(d, p) for p in perm])\n", " if a.norm() != 0:\n", " states.append(a)\n", " Q = qt.Qobj(np.array([state.full().T[0].tolist() for state in states]))\n", " Q.dims[1] = [d]*n\n", " return Q\n", " \n", "a = qt.rand_ket(2)\n", "print(a)\n", "b = qt.rand_ket(2)\n", "print(b)\n", "\n", "c = antisymmetrize(a,b)\n", "print(c)\n", "print(swap()*c)\n", "\n", "antisymmetric_basis(3, d=3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we put the two together.\n", "\n", "We tensor, say, $3$ fermionic oscillators, and construct the total number operator. Then we construct a permutation matrix that rearranges the number operator so that its eigenvalues are in order. We can also use this permutation matrix $P$ to rearrange a Fock state so that it's of the form: $H_{1} \\oplus H_{3} \\oplus H_{3} \\oplus H_{1}$. The dimensionality of these Hilbert spaces corresponds to the dimensionality of the antisymmetric subspace of the tensor product of $0, 1, 2$, and $3$ particles. So once we've picked apart out state, we can apply the linear map constructed above which sends:\n", "\n", "$H_{1} \\oplus H_{3} \\oplus H_{3} \\oplus H_{1} \\rightarrow 0 \\oplus A(H_{3}) \\oplus A(H_{3}, H_{3}) \\oplus A(H_{3}, H_{3}, H_{3})$, where $A()$ denotes the antisymmetric subspace of the tensor product of the particles." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import qutip as qt\n", "import numpy as np\n", "from itertools import product\n", "\n", "def construct_permutation(n): \n", " tensor_basis_labels = list(product([0,1], repeat=n))\n", " total_n_basis_labels = []\n", " for i in range(n+1):\n", " total_n_basis_labels.extend(\\\n", " list(filter(lambda x: sum(x) == i, list(product([0,1], repeat=n))))[::-1])\n", " P = np.zeros((2**n, 2**n))\n", " for i, label in enumerate(tensor_basis_labels):\n", " P[total_n_basis_labels.index(label)][i] = 1\n", " P = qt.Qobj(P)\n", " P.dims = [[2]*n, [2]*n]\n", " sums = [sum(label) for label in total_n_basis_labels]\n", " unique_sums = set(sums)\n", " dims = [sums.count(us) for us in unique_sums]\n", " return P, dims \n", "\n", "def extract_states(q, dims):\n", " v = q.full().T[0]\n", " running = 0\n", " blocks = []\n", " for d in dims:\n", " blocks.append(qt.Qobj(v[running:running+d]))\n", " running += d\n", " return blocks\n", "\n", "def osc_antisymmetrics(state):\n", " n = len(state.dims[0])\n", " P, dim = construct_permutation(n)\n", " extracted = extract_states(P*state, dim)\n", " finished = [extracted[0]]\n", " for i in range(1, len(extracted)):\n", " finished.append(antisymmetric_basis(i, d=n).dag()*extracted[i])\n", " return finished\n", " \n", "#########################################################################################\n", "\n", "n = 3\n", "IDn = qt.identity(2**n)\n", "IDn.dims = [[2]*n, [2]*n]\n", "\n", "f = fermion_operators(n)\n", "N = sum([a.dag()*a for a in f])\n", "\n", "print(N)\n", "P, dim = construct_permutation(n)\n", "N_ = P*N*P.dag()\n", "print(N_)\n", "\n", "state = qt.rand_ket(2**n)\n", "state.dims = [[2]*n, [1]*n]\n", "\n", "print(\"\\n Extracted sectors:\")\n", "print(extract_states(P*state, dim))\n", "print(\"\\nTower of antisymmetric states:\\n\")\n", "antisymmetric_tower = osc_antisymmetrics(state)\n", "print(antisymmetric_tower)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So there you have it: fermionic quantization.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Now you might wonder about the following fact:\n", "\n", "It is often said that bosons are permutation symmetric particles with *integer spin* and fermions are permutation antisymmetric particles with *half integer spin*. This doesn't actually follow from anything we've discussed so far, even though we know quite a lot about spin, and also how to quantize things bosonically and fermionically. What it has to do with is the so-called \"spin-statistics theorem.\"\n", "\n", "First, a word about integer vs. half integer spin. This is the first clue. After all, what is the effect of representing rotations with $SU(2)$ acting on spinors instead of $SO(3)$ acting on $(x, y, z)$ vectors? We actually get something extra. $SU(2)$ isn't just identical to the 3D rotation group: in fact, it's the double cover of the 3D rotation group: for each element of the 3D rotation group, there are *two* elements of $SU(2)$. Take a spin-$\\frac{1}{2}$ state and rotate it a full turn by exponentiating some Pauli matrix. You'll find that the state actually comes back to itself times $-1$. It'll only come back to itself exactly if you give it another full turn. So you actually have to turn a spin-$\\frac{1}{2}$ state $720^{\\circ}$ to make a full \"rotation\": it takes twice has much. Hence, the double cover: there are effectively two copies of the rotation group sitting inside $SU(2)$ so they can keep track of this negative sign. This is true for all half integer spin states: a full turn takes them to the negative of themselves, but the phase will wind around a bunch of times as it gets there. In contrast, integer spin states come back to themselves under a $360^{\\circ}$ rotation (although the phase might wind around a lot for higher states.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import qutip as qt\n", "import numpy as np\n", "import vpython as vp\n", "from examples.magic import *\n", "\n", "def get_phase(q):\n", " c = sum(q.full().T[0][::-1])\n", " return np.exp(1j*np.angle(c))\n", "\n", "scene = vp.canvas(background=vp.color.white)\n", "\n", "j = 3/2\n", "n = int(2*j + 1)\n", "dt = 0.001\n", "state = qt.rand_ket(n)\n", "H = qt.jmat(j, 'y')\n", "U = (-1j*H*dt).expm()\n", "\n", "vp.sphere(color=vp.color.blue, opacity=0.5)\n", "initial_vstars = [vp.sphere(pos=vp.vector(*xyz),\\\n", " radius=0.2, emissive=True,\\\n", " color=vp.color.yellow) \n", " for xyz in spin_XYZ(state)]\n", "\n", "vstars = [vp.sphere(pos=vp.vector(*xyz),\\\n", " radius=0.2, emissive=True) \n", " for xyz in spin_XYZ(state)]\n", "\n", "phase = get_phase(state)\n", "initial_vphase = vp.arrow(pos=vp.vector(0,2,0),color=vp.color.yellow,\\\n", " axis=vp.vector(phase.real, phase.imag, 0))\n", "vphase = vp.arrow(pos=vp.vector(0,2,0),\\\n", " axis=vp.vector(phase.real, phase.imag, 0))\n", "\n", "while True:\n", " state = U*state\n", " for i, xyz in enumerate(spin_XYZ(state)):\n", " vstars[i].pos = vp.vector(*xyz)\n", " phase = get_phase(state)\n", " vphase.axis = vp.vector(phase.real, phase.imag, 0)\n", " vp.rate(1000)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So already, it sort of might make intuitive sense that half integer particles might have to do with fermions: there's that $-1$! \n", "\n", "But that assumes some kind of connection between *rotations* and *permutations in the tensor product*.\n", "\n", "After all, we've quantized spin-$\\frac{1}{2}$ states as bosons and everything turned out fine. We can form permutation symmetric states, and swap the particles in them without picking up a $-1$. That only comes in if we were to rotate one of the particles individually, but of course, that would break the permutation symmetry, which suggests we can't act on just one boson, but have to act on them all symmetrically. Either way, the full state will pick up a global negative $-1$ due to the rotation. \n", "\n", "In fact, the classic proofs of the spin statistics theorem involve invoking some high powered machinery from quantum field theory and special relativity in 3+1 dimensions, which we can't go into here.\n", "\n", "Instead, however, let's look at an interesting construction thanks to Berry and Robbins, who approach the proof from a different angle. It involves the oscillator representation of spin, so it'll be a good example of that too!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "\n", "So we have three concepts we want to combine: that of a swap in the tensor product, a rotation of spin, and an actual exchange of position. Take two objects $A$ and $B$, put them side to side, and swap them. Imagine you were $A$: what would you see? As $B$ circles around you, you start to see $B$'s underside, and then eventually $B$'s far side. In other words, $A$ would see a swap as: half a rotation of $B$, a rotation of $\\pi$ radians. So let's ignore their actual position, and describe things just from $A$ and $B$'s point of view on each other. That leaves us with two things: we want to combine a $180^{\\circ}$ rotation with a swap in the tensor product.\n", "\n", "In order to do this, we're going to use our oscillator construction of spin, where each spin gets two oscillators. By the way, you can think of this like taking the \"square root\" of the spin. Being able to split a spin into two oscillators turns out to be very useful here.\n", "\n", "Suppose we have two spins. So we have four oscillators in total, with annihilators: $a_{\\uparrow}, a_{\\downarrow}, b_{\\uparrow}, b_{\\downarrow}$. As we well know, we can upgrade our spin-$\\frac{1}{2}$ $X, Y, Z$ operators to act on the pair of $a$ oscillators.\n", "\n", "$X = \\begin{pmatrix} a_{\\uparrow}^{\\dagger} & a_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix} \\begin{pmatrix} a_{\\uparrow} \\\\ a_{\\downarrow}\\end{pmatrix} = \\begin{pmatrix} a_{\\uparrow}^{\\dagger} & a_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} a_{\\downarrow} \\\\ a_{\\uparrow}\\end{pmatrix} = a_{\\uparrow}^{\\dagger}a_{\\downarrow} + a_{\\downarrow}^{\\dagger}a_{\\uparrow}$\n", "\n", "$Y = \\begin{pmatrix} a_{\\uparrow}^{\\dagger} & a_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} 0 & -i \\\\ i & 0 \\end{pmatrix} \\begin{pmatrix} a_{\\uparrow} \\\\ a_{\\downarrow}\\end{pmatrix} = \\begin{pmatrix} a_{\\uparrow}^{\\dagger} & a_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} -ia_{\\downarrow} \\\\ ia_{\\uparrow}\\end{pmatrix} = -ia_{\\uparrow}^{\\dagger}a_{\\downarrow} + ia_{\\downarrow}^{\\dagger}a_{\\uparrow}$\n", "\n", "$Z = \\begin{pmatrix} a_{\\uparrow}^{\\dagger} & a_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix} \\begin{pmatrix} a_{\\uparrow} \\\\ a_{\\downarrow}\\end{pmatrix} = \\begin{pmatrix} a_{\\uparrow}^{\\dagger} & a_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} a_{\\uparrow} \\\\ -a_{\\downarrow}\\end{pmatrix} = a_{\\uparrow}^{\\dagger}a_{\\uparrow} - a_{\\downarrow}^{\\dagger}a_{\\downarrow}$\n", "\n", "We can do the same with the $b$ oscillators:\n", "\n", "$X = \\begin{pmatrix} b_{\\uparrow}^{\\dagger} & b_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix} \\begin{pmatrix} b_{\\uparrow} \\\\ b_{\\downarrow}\\end{pmatrix} = \\begin{pmatrix} b_{\\uparrow}^{\\dagger} & b_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} b_{\\downarrow} \\\\ b_{\\uparrow}\\end{pmatrix} = b_{\\uparrow}^{\\dagger}b_{\\downarrow} + b_{\\downarrow}^{\\dagger}b_{\\uparrow}$\n", "\n", "$Y = \\begin{pmatrix} b_{\\uparrow}^{\\dagger} & b_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} 0 & -i \\\\ i & 0 \\end{pmatrix} \\begin{pmatrix} b_{\\uparrow} \\\\ b_{\\downarrow}\\end{pmatrix} = \\begin{pmatrix} b_{\\uparrow}^{\\dagger} & b_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} -ib_{\\downarrow} \\\\ ib_{\\uparrow}\\end{pmatrix} = -ib_{\\uparrow}^{\\dagger}b_{\\downarrow} + ib_{\\downarrow}^{\\dagger}b_{\\uparrow}$\n", "\n", "$Z = \\begin{pmatrix} b_{\\uparrow}^{\\dagger} & b_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix} \\begin{pmatrix} b_{\\uparrow} \\\\ b_{\\downarrow}\\end{pmatrix} = \\begin{pmatrix} b_{\\uparrow}^{\\dagger} & b_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} b_{\\uparrow} \\\\ -b_{\\downarrow}\\end{pmatrix} = b_{\\uparrow}^{\\dagger}b_{\\uparrow} - b_{\\downarrow}^{\\dagger}b_{\\downarrow}$\n", "\n", "But why stop there? We have four oscillators after all. We could consider spins built out of *cross-oscillators*, taking as pairs: the two $\\uparrow$ oscillators (of $a$ and $b$ each):\n", "\n", "$X = \\begin{pmatrix} a_{\\uparrow}^{\\dagger} & b_{\\uparrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix} \\begin{pmatrix} a_{\\uparrow} \\\\ b_{\\uparrow}\\end{pmatrix} = \\begin{pmatrix} a_{\\uparrow}^{\\dagger} & b_{\\uparrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} b_{\\uparrow} \\\\ a_{\\uparrow}\\end{pmatrix} = a_{\\uparrow}^{\\dagger}b_{\\uparrow} + b_{\\uparrow}^{\\dagger}a_{\\uparrow}$\n", "\n", "$Y = \\begin{pmatrix} a_{\\uparrow}^{\\dagger} & b_{\\uparrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} 0 & -i \\\\ i & 0 \\end{pmatrix} \\begin{pmatrix} a_{\\uparrow} \\\\ b_{\\uparrow}\\end{pmatrix} = \\begin{pmatrix} a_{\\uparrow}^{\\dagger} & b_{\\uparrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} -ib_{\\uparrow} \\\\ ia_{\\uparrow}\\end{pmatrix} = -ia_{\\uparrow}^{\\dagger}b_{\\uparrow} + ib_{\\uparrow}^{\\dagger}a_{\\uparrow}$\n", "\n", "$Z = \\begin{pmatrix} a_{\\uparrow}^{\\dagger} & b_{\\uparrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix} \\begin{pmatrix} a_{\\uparrow} \\\\ b_{\\uparrow}\\end{pmatrix} = \\begin{pmatrix} a_{\\uparrow}^{\\dagger} & b_{\\uparrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} a_{\\uparrow} \\\\ -b_{\\uparrow}\\end{pmatrix} = a_{\\uparrow}^{\\dagger}a_{\\uparrow} - b_{\\uparrow}^{\\dagger}b_{\\uparrow}$\n", "\n", "As well as the two $\\downarrow$ oscillators:\n", "\n", "$X = \\begin{pmatrix} a_{\\downarrow}^{\\dagger} & b_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix} \\begin{pmatrix} a_{\\downarrow} \\\\ b_{\\downarrow}\\end{pmatrix} = \\begin{pmatrix} a_{\\downarrow}^{\\dagger} & b_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} b_{\\downarrow} \\\\ a_{\\downarrow}\\end{pmatrix} = a_{\\downarrow}^{\\dagger}b_{\\downarrow} + b_{\\downarrow}^{\\dagger}a_{\\downarrow}$\n", "\n", "$Y = \\begin{pmatrix} a_{\\downarrow}^{\\dagger} & b_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} 0 & -i \\\\ i & 0 \\end{pmatrix} \\begin{pmatrix} a_{\\downarrow} \\\\ b_{\\downarrow}\\end{pmatrix} = \\begin{pmatrix} a_{\\downarrow}^{\\dagger} & b_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} -ib_{\\downarrow} \\\\ ia_{\\downarrow}\\end{pmatrix} = -ia_{\\downarrow}^{\\dagger}b_{\\downarrow} + ib_{\\downarrow}^{\\dagger}a_{\\downarrow}$\n", "\n", "$Z = \\begin{pmatrix} a_{\\downarrow}^{\\dagger} & b_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix} \\begin{pmatrix} a_{\\downarrow} \\\\ b_{\\downarrow}\\end{pmatrix} = \\begin{pmatrix} a_{\\downarrow}^{\\dagger} & b_{\\downarrow}^{\\dagger} \\end{pmatrix} \\begin{pmatrix} a_{\\downarrow} \\\\ -b_{\\downarrow}\\end{pmatrix} = a_{\\downarrow}^{\\dagger}a_{\\downarrow} - b_{\\downarrow}^{\\dagger}b_{\\downarrow}$\n", "\n", "Now suppose we evolve with $e^{-i\\theta (Y_{a_{\\uparrow}b_{\\uparrow}} + Y_{a_{\\downarrow}b_{\\downarrow}})}$, in other words, perform a simultaneous $Y$ rotation of $\\theta$ degrees to the two cross spins. If we watch what happens to the original spins during this $Y$ rotation, after a turn of $\\pi$, the two spins will have swapped places in the tensor product. A turn of $2\\pi$ returns them back to where they began. And so, we've unified rotations and permutations.\n", "\n", "Moreover, if we consider doing this permutation/rotation to states with different $j$ values, trying out $\\frac{1}{2}, 1, \\frac{3}{2}, 2, \\dots$, we find that: for half-integer spins, the state is multiplied by $-1$ after a swap, but not for integer spins. So that if we do a rotation/swap, half integer spins act like fermions, picking up a sign; but integer spins act like bosons, permuting without picking up a sign. That's hardly a complete proof, but it's suggestive!" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import qutip as qt\n", "import numpy as np\n", "import math\n", "import vpython as vp\n", "\n", "##########################################################################################\n", "\n", "def get_phase(q):\n", " c = sum(q.full().T[0][::-1])\n", " return np.exp(1j*np.angle(c))\n", "\n", "def second_quantize_operator(O, a):\n", " O = O.full()\n", " terms = []\n", " for i in range(len(a)):\n", " for j in range(len(a)):\n", " terms.append(a[i].dag()*O[i][j]*a[j])\n", " return sum(terms)\n", "\n", "def second_quantize_state(state, a):\n", " v = state.full().T[0]\n", " return sum([v[i]*a[i] for i in range(len(a))]).dag()\n", "\n", "def second_quantize_spin_state(spin, a):\n", " n = spin.shape[0]-1\n", " j = (spin.shape[0]-1)/2.\n", " v = spin.full().T[0]\n", " terms = []\n", " z, w = [a_.dag() for a_ in a]\n", " for m in np.arange(-j, j+1, 1):\n", " i = int(m+j)\n", " terms.append(v[i]*(z**(n-i))*(w**i)*\\\n", " (math.sqrt(math.factorial(2*j)/\\\n", " (math.factorial(j-m)*math.factorial(j+m)))))\n", " return sum(terms)\n", " \n", "def upgrade(O, i, n):\n", " ID = qt.identity(O.shape[0])\n", " ID.dims = O.dims\n", " return qt.tensor(*[O if i==j else ID for j in range(n)])\n", "\n", "##########################################################################################\n", "\n", "max_ex = 5\n", "a = [upgrade(qt.destroy(max_ex), 0, 4), upgrade(qt.destroy(max_ex), 1, 4)]\n", "b = [upgrade(qt.destroy(max_ex), 2, 4), upgrade(qt.destroy(max_ex), 3, 4)]\n", "\n", "XYZ = [0.5*qt.sigmax(), 0.5*qt.sigmay(), 0.5*qt.sigmaz()]\n", "XYZa = [second_quantize_operator(O, a) for O in XYZ]\n", "XYZb = [second_quantize_operator(O, b) for O in XYZ]\n", "XYZab = [second_quantize_operator(O, [a[0], b[0]]) for O in XYZ]\n", "XYZba = [second_quantize_operator(O, [a[1], b[1]]) for O in XYZ]\n", "\n", "Na = sum([a_.dag()*a_ for a_ in a])/2\n", "Nb = sum([b_.dag()*b_ for b_ in b])/2\n", "Nab = (a[0].dag()*a[0] + b[0].dag()*b[0])/2\n", "Nba = (a[1].dag()*a[1] + b[1].dag()*b[1])/2\n", "\n", "##########################################################################################\n", "\n", "vac = qt.basis(a[0].shape[0])\n", "vac.dims = [a[0].dims[0], [1]*len(a[0].dims[0])]\n", "a_state = qt.rand_ket(2)\n", "b_state = qt.rand_ket(2)\n", "\n", "# try spin-1/2\n", "state = second_quantize_spin_state(a_state, a)*second_quantize_spin_state(b_state, b)*vac\n", "# try spin-1\n", "#state = second_quantize_spin_state(a_state, a)*second_quantize_spin_state(b_state, b)*second_quantize_spin_state(a_state, a)*second_quantize_spin_state(b_state, b)*vac\n", "\n", "# try tensor state\n", "#ab_state = qt.bell_state(\"00\")\n", "#ab_tensor = [a[0]*b[0], a[0]*b[1], a[1]*b[0], a[1]*b[1]]\n", "#state = second_quantize_state(ab_state, ab_tensor)*second_quantize_state(ab_state, ab_tensor)*vac\n", "\n", "state = state.unit()\n", "\n", "##########################################################################################\n", "\n", "scene = vp.canvas(background=vp.color.white, width=1000, height=800)\n", "\n", "vA = vp.sphere(pos=vp.vector(-1.5, 0, 0), radius=qt.expect(Na, state), color=vp.color.blue, opacity=0.3)\n", "vB = vp.sphere(pos=vp.vector(1.5, 0, 0), radius=qt.expect(Nb, state), color=vp.color.red, opacity=0.3)\n", "vAB = vp.sphere(pos=vp.vector(0, 1.5, 0), radius=qt.expect(Nab, state), color=vp.color.yellow, opacity=0.3)\n", "vBA = vp.sphere(pos=vp.vector(0, -1.5, 0), radius=qt.expect(Nba, state), color=vp.color.green, opacity=0.3)\n", "\n", "vA_arrow = vp.arrow(pos=vA.pos,\\\n", " axis=vp.vector(*[qt.expect(O, state) for O in XYZa]))\n", "vB_arrow = vp.arrow(pos=vB.pos,\\\n", " axis=vp.vector(*[qt.expect(O, state) for O in XYZb]))\n", "vAB_arrow = vp.arrow(pos=vAB.pos,\\\n", " axis=vp.vector(*[qt.expect(O, state) for O in XYZab]))\n", "vBA_arrow = vp.arrow(pos=vBA.pos,\\\n", " axis=vp.vector(*[qt.expect(O, state) for O in XYZba]))\n", "\n", "vA_origA = vp.sphere(pos=vA.pos+vA_arrow.axis, color=vp.color.blue, radius=0.15)\n", "vA_origB = vp.sphere(pos=vB.pos+vA_arrow.axis, color=vp.color.blue, radius=0.15)\n", "vB_origA = vp.sphere(pos=vA.pos+vB_arrow.axis, color=vp.color.red, radius=0.15)\n", "vB_origB = vp.sphere(pos=vB.pos+vB_arrow.axis, color=vp.color.red, radius=0.15)\n", "\n", "phase = get_phase(state)\n", "initial_vphase = vp.arrow(pos=vp.vector(0,0,0),color=vp.color.yellow,\\\n", " axis=0.5*vp.vector(phase.real, phase.imag, 0))\n", "vphase = vp.arrow(pos=vp.vector(0,0,0),\\\n", " axis=0.5*vp.vector(phase.real, phase.imag, 0))\n", "\n", "##########################################################################################\n", "\n", "dt = 0.0005\n", "U = (-1j*(XYZba[1]+XYZab[1])*dt).expm()\n", "\n", "T, t = 0, 0\n", "#while T < np.pi:\n", "while True:\n", " state = U*state\n", " vA_arrow.axis = vp.vector(*[qt.expect(O, state) for O in XYZa])\n", " vB_arrow.axis = vp.vector(*[qt.expect(O, state) for O in XYZb])\n", " vAB_arrow.axis = vp.vector(*[qt.expect(O, state) for O in XYZab])\n", " vBA_arrow.axis = vp.vector(*[qt.expect(O, state) for O in XYZba])\n", " vA.radius = qt.expect(Na, state)\n", " vB.radius = qt.expect(Nb, state)\n", " vAB.radius = qt.expect(Nab, state)\n", " vBA.radius = qt.expect(Nba, state)\n", " #print(qt.entropy_vn(state.ptrace(0,1)), qt.entropy_vn(state.ptrace(2,3)))\n", " T += dt\n", "\n", " t += 1\n", " if t % 100 == 0:\n", " phase = get_phase(state)\n", " vphase.axis = 0.5*vp.vector(phase.real, phase.imag, 0)\n", " vp.rate(1000)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "Some references:\n", "\n", "Back and forth from Fock space to Hilbert space: a guide for commuters\n", "\n", "Indistinguishability for Quantum Particles: Spin, Statistics and the Geometric Phase\n", "\n", "Group Representations and the Quantum Statistics of Spin\n", "\n", "The Geometry of Classical Particles\n", "\n", "Configurations of Points\n", "\n", "Atiyah's Edinburgh Lectures on Geometry, Analysis and Physics\n", "" ] } ], "metadata": { "kernelspec": { "display_name": "VPython", "language": "python", "name": "vpython" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.7" } }, "nbformat": 4, "nbformat_minor": 4 }