Homework 1 Quantum Mechanics Christian von Schultz 11 september 2008

1.1 We shall show that tr(|ui hv|) = hu|vi. P Using the definition of the trace of an operator, tr X = i hαi |X|αi i, where the |αi i are an orthonormal basis to the vector space, we get: X tr(|ui hv|) = hαi |ui hv|αi i = i

(associativity of everything, commutiativity of inner products) X = hv|αi i hαi |ui = [completeness relation] = hv|ui , i

quod erat demonstrandum.

1.2 Assume U = exp(iH), H Hermitian. Show U is unitary U † = exp(−iH † ) = [H is Hermitian] = exp(−iH) U † U = exp(−iH) exp(iH) = [H commutes with itself] = = exp(−iH + iH) = exp(0) = 1 Since U † U = 1, U is unitary.

1

Show det U = exp(i tr H) Choose a basis where H is diagonal, H = diag(λ1 , λ2 , . . .). By the definition of U , we will have U = diag(exp(iλ1 ), exp(iλ2 ), . . .). Now, Y X lhs = det U = exp(iλi ) = exp(i λi ) = exp(i tr H) = rhs i

i

Since this holds true in one basis, it works in every basis. Check numerically and compute tanh H This is done by the following code in GNU Octave: H = [ 16, 15, 12, 7; \ 15, 13, 8, 11; \ 12, 8, 0, 10; \ 7, 11, 10, 2 ]; [ P, epsilon ] = eig(H); #U = P * (exp(i * epsilon) .* eye(size(epsilon))) * P’ U = expm(i*H); printf("det(U) = %.10f and exp(i tr(H)) = %.10f.\n", det(U), \ exp(i * trace(H))); tanhH = P * tanh(epsilon) * P’ format long trace(tanhH) Note that if we were to calculate U by hand, we need to both diagonalise the matrix and compensate for the fact that exp(0) equals one. However, clever people have devised a better algorithm than my na¨ıve one (commented out above), so I’m using expm instead. With tanh we don’t have that problem: since tanh 0 = 0 it won’t touch the elements off the diagonal, so that we can take tanh of a diagonal matrix without worrying about Octave doing stuff element wise. The result is: det(U) = 0.9147423578 and exp(i tr(H)) = 0.9147423578. tanhH = 0.796480 0.120933 0.438060 -0.298872

0.120933 0.066264 0.415633 0.831390

0.438060 0.415633 -0.671369 0.335639

ans = 0.0445061739120566 2

-0.298872 0.831390 0.335639 -0.146868

1.3 Given operators Ω and Λ with [[Ω, Λ], Ω] = 0, show that [Ωm , Λ] = mΩm−1 [Ω, Λ]. This statement bears a great similarity to the familiar ∂t xm = mxm−1 ∂t x, and I’m going to prove it in the same way that statement is proved: by mathematical induction. Starting at m = 1 (so we don’t need to assume that Ω has an inverse — we will deal with the case that it does presently). lhs = [Ω1 , Λ] = [Ω, Λ] rhs = 1 · Ω0 [Ω, Λ] = [Ω, Λ] lhs = rhs and the statement works for m = 1. Assuming that it works for m ≤ p, prove that it works for m = p + 1: ?

[Ωp+1 , Λ] = (p + 1)Ωp [Ω, Λ] We will need an analogue of the product rule: [ab, Λ] = abΛ − Λab = a(bΛ − Λb) + aΛb − Λab = a[b, Λ] + [a, Λ]b

(1)

for any operators a and b. So, with a = Ω and b = Ωm , we have lhs = [Ωp+1 , Λ] = Ω[Ωp , Λ] + [Ω, Λ]Ωp = [by assumption] = = ΩpΩp−1 [Ω, Λ] + [Ω, Λ]Ωp = (using commutativity of the commutator with Ω, i.e. [[Ω, Λ], Ω] = 0) = pΩp [Ω, Λ] + Ωp [Ω, Λ] = (p + 1)Ωp [Ω, Λ] = rhs. Thus, if the statement holds for m = p, it will also hold for m = p + 1. By the axiom of induction the two previous sub-proofs prove the statement for any positive integer m.

3

Z

If the inverse of Ωm exists for any m ∈ we can consider the statement for m = 0 and for the negative integers. For m = 0 the statement is obviously true: it simply states that the identity operator Ω0 commutes with Λ. For negative m, m = −p, we use the product rule (1) gives us 0 = [1, Λ] = [Ω−p Ωp , Λ] = Ω−p [Ωp , Λ] + [Ω−p , Λ]Ωp = = Ω−p pΩp−1 [Ω, Λ] + [Ω−p , Λ]Ωp

=⇒

[Ω−p , Λ]Ωp = −pΩ−1 [Ω,Λ]

Now, if Ω commutes with the commutator [Ω, Λ], Ω−p will too. So we apply Ω−p to the left of both sides, and arrive at [Ω−p , Λ]Ωp = −pΩ−p−1 [Ω, Λ]

Z

and now the statement has been proved for all n ∈ .

1.4 “Assume two Hermitian operators anticummute A, B = AB + BA = 0. Is it possible to have a simultaneous (i.e. common) eigenket of A and B. Prove your assertion.” It is possible, but only if one of the eigenvalues is zero. If |ψi is an eigenstate of both operators, we have AB |ψi = Ab |ψi = bA |ψi = ab |ψi BA |ψi = Ba |ψi = aB |ψi = ab |ψi where a and b are the eigenvalues. We then have AB |ψi = BA |ψi =⇒ (AB − BA) |ψi = 0 =⇒ (AB + BA − 2BA) |ψi = 0 BA |ψi = 0 =⇒ a = 0 or b = 0 Proof by construction: Take A and B to be     1 0 0 0 A= , B= . 0 0 0 1 These are obviously Hermitian. They anticommute, because AB = BA = 0. The vector |ψi = (1, 0) is an eigenvector of both matrices: A |ψi = 1 |ψi :

eigenvalue 1

B |ψi = 0 |ψi :

eigenvalue 0

There is nothing wrong with having eigenvalue zero, it is only the eigenvector that must be non-zero. So, it is possible. Statement proved by construction. 4

1.5 Assume the operator a obeys [a, a† ] = 1, and define n = a† a. Show that am (a† )m where m is integer, can be written as a function of the operator n by (n + 1)(n + 2) · · · (n + m). In mathematical notation, the statement is m Y a (a ) = (n + i) m

† m

(2)

i=1

where we shall understand the factors to come in order of increasing i, from left to right. The product only makes sense for the positive integers. I will be needing a lemma, which I will prove first: AB n = B n A + n[A, B]B n−1 , for [A, B] ∈

C

(3)

For n = 1 this reduces to the familiar order-changing rule, AB = BA+[A, B]. Taking the rest by mathematical induction, we assume that (3) works for n ≤ p, and set out to prove it for n = p + 1: lhs(p + 1) = AB p+1 = AB p B = B p AB + p[A, B]B p−1 B = = B p+1 A + B p [A, B] + p[A, B]B p = B p+1 A + (p + 1)[A, B]B p = rhs(p + 1). By the axiom of induction, our lemma (3) holds for all positive integers n. We will now proceed to prove (2) using mathematical induction! Starting at m = 1 we find lhs(1) = a1 (a† )1 = aa† = a† a + [a, a† ] = n + 1 = rhs(1) The statement (2) works for m = 1. Assuming that it works for m ≤ p we prove that it works for m = p + 1: lhs(p + 1) = ap a(a† )p+1 = (3) = ap (a† )p a† a + ap (p + 1)[a, a† ](a† )p = = ap (a† )p n + (p + 1)ap (a† )p = ap (a† )p (n + p + 1) = ! p+1 p Y Y (n + i) (n + p + 1) = (n + i) = rhs(p + 1). = i=1

i=1

Thus the statement (2) holds for m = p + 1 if it holds for m = p. 5

By the axiom of induction the two previous sub-proofs prove the statement for any positive integer m.

1.6 I verify that [A, B] = 0 in the next section. I don’t know how to solve the rest of problem both numerically and exactly. When you do things numerically, you don’t do it exactly. If you wanted it exact you would use software such as Mathematica or Maple, which would give you an analytical solution — but that would not count as ”numerically computing” something. Using Maple, I form the matrix A + B, which commutes with both of them. Then I right-click and ask for the eigenvectors, and get the response   1 1 − 21 −1 1 0  1 1 1 If Maple has done this correctly, these eigenvectors should simultaneously diagonalise A and B.

1.7 This task has been solved by the following Octave program. It prints the answer to each question posed in the task (program printout follows). A few noteworthy points: I use integer arithmetic whenever possible, e.g. to calculate the commutators. Integer arithmetic is exact. I also use the Octave functions expm and logm that take the exponential and logarithm of a matrix, respectively. That spares me the trouble of diagonalising, applying the function to the diagonal elements only and multiplying everything together again. tioA = [ 4, -3, -1; -2, tioB = [ 8, -3, 1; -2, tioC = [ 2, 5, 0; 5, # Integer arithmetic is

3, -1; -2, -3, 5 ] 9, -1; 2, -3, 7 ] 8, 2; 0, 2, 0 ] exact, that’s why I won’t divide here.

printf("A and B commute: [A, B] = \n"); disp((tioA*tioB-tioB*tioA)/100); printf("\n"); printf("C does not commute with A: [A, C] = \n");

6

disp((tioA*tioC - tioC*tioA)/100); printf("... nor does it commute with B: [B, C] = \n"); disp((tioB*tioC - tioC*tioB)/100); printf("\n"); format long A = tioA/10; # Now we cannot do exact arithmetic anyway. B = tioB/10; C = tioC/10; printf("exp(A) * exp(B) = \n"); disp(expm(A) * expm(B)) printf("and exp(A+B) = \n"); disp(expm((tioA+tioB)/10)); printf(["Apart from some very small numerical errors, ",\ "these are seen to be identical.\n\n"]); printf("exp(A) * exp(C) = \n"); disp(expm(A) * expm(C)); printf("exp(A+C) = \n"); disp(expm(A+C)); printf(["Here we see some rather large differences, ",\ "far too large to blame on numerical errors.\n\n"]); printf("exp(A)*exp(C)*exp(-(A+C)) = \n"); disp(expm(A)*expm(C)*expm(-(A+C))); printf(["This expression would have been the identity matrix,",\ " if A and C were commuting.\n\n"]); printf("Delta1 =\n"); Delta1 = logm(expm(A)*expm(C)) - (A + C); disp(Delta1); printf("gives exp(A) * exp(C) - exp(A+C+Delta1) = \n"); disp(expm(A) * expm(C) - expm(A + C + Delta1)) printf("which is comparable to machine precision eps = %e.\n\n",\ eps); printf("Delta2 = \n"); Delta2 = logm(expm(A)*expm(C)) \ - (A + C + (tioA*tioC-tioC*tioA)/200); disp(Delta2); printf("gives exp(A) * exp(C) - exp(A+C+[A,C]/2+Delta2) = \n"); disp(expm(A) * expm(C) \ - expm(A + C +(tioA*tioC-tioC*tioA)/200 + Delta2))

7

printf("which is comparable to machine precision eps = %e.\n\n",\ eps);

tioA = 4 -2 -2

-3 3 -3

-1 -1 5

tioB = 8 -2 2

-3 9 -3

1 -1 7

tioC = 2 5 0

5 8 2

A and B 0 0 0 0 0 0

0 2 0 commute: [A, B] = 0 0 0

C does not commute with -0.050000 -0.150000 0.110000 0.090000 -0.150000 -0.300000 ... nor does it commute -0.050000 -0.210000 0.130000 0.090000 -0.070000 -0.180000 exp(A) * exp(B) = 3.730627729180000 -1.409176221340812 0.410510806443453 and exp(A+B) = 3.730627729180001 -1.409176221340812

A: [A, C] = 0.010000 0.090000 -0.040000 with B: [B, C] = -0.030000 0.070000 -0.040000

-2.113764332011219 3.935883132401728 -2.113764332011218

0.205255403221727 -0.704588110670406 3.525372325958274

-2.113764332011218 3.935883132401727

0.205255403221727 -0.704588110670406

8

0.410510806443453 -2.113764332011218 3.525372325958274 Apart from some very small numerical errors, these are seen to be identical. exp(A) * exp(C) = 1.819252555754865 0.287887855040642 -0.160603730290097 0.840347022700137 3.238028891677752 0.293505176911444 -0.625853931161193 -0.724204191619147 1.578888048172737 exp(A+C) = 1.904937427129102 0.488675064867517 -0.154543209357838 0.696038464270014 3.068522880248769 0.196799361393565 -0.383034684778198 -0.270747627456088 1.655317875690877 Here we see some rather large differences, far too large to blame on numerical errors. exp(A)*exp(C)*exp(-(A+C)) = 0.97791723582025947 -0.06177464795745258 0.00162141007939608 0.06958990799484369 1.04936790289072657 0.05904901584856526 -0.08477542871947755 -0.13760481271438002 0.96227265107362026 This expression would have been the identity matrix, if A and C were commuting. Delta1 = -0.04152038149253112 -0.09497575161149741 -0.00518535214528967 0.06519127692955567 0.07536972145125631 0.04338781615923445 -0.10480828248556201 -0.19629711971202168 -0.03384933995872619 gives exp(A) * exp(C) - exp(A+C+Delta1) = 4.44089209850063e-16 1.27675647831893e-15 -4.16333634234434e-16 2.33146835171283e-15 2.22044604925031e-15 -1.11022302462516e-16 -1.55431223447522e-15 -9.99200722162641e-16 2.22044604925031e-16 which is comparable to machine precision eps = 2.220446e-16. Delta2 = -0.01652038149253110 -0.01997575161149739 -0.01018535214528968 0.01019127692955568 0.03036972145125638 -0.00161218384076556 -0.02980828248556200 -0.04629711971202169 -0.01384933995872617 gives exp(A) * exp(C) - exp(A+C+[A,C]/2+Delta2) = 4.44089209850063e-16 1.27675647831893e-15 -4.16333634234434e-16 2.33146835171283e-15 2.22044604925031e-15 -1.11022302462516e-16 -1.55431223447522e-15 -9.99200722162641e-16 2.22044604925031e-16 which is comparable to machine precision eps = 2.220446e-16.

Now, being comparable to machine precision means that it is indistinguishable from zero. That means that we have obtained the correct ∆1 and ∆2 . 9

Perhaps not to the last digit, but the first handful of decimal places ought to be correct.

10