Bivector form of quantum angular momentum operator (derivatives of spherical polar unit vectors and bivectors)

[Click here for a PDF of this sequence of posts with nicer formatting]

Applying the vector derivative commutator (or not).

Let’s express the and unit vectors explicitly in terms of the standard basis. Starting with we have

Explicitly in vector form, eliminating the exponential, this is , but it is more convenient to keep the exponential as is.

For we have

Again, explicitly this is , but we’ll use the exponential form above. Last we want

Summarizing we have

Or without exponentials

Now, having worked out the cool commutator result, it appears that it will actually be harder to use it, then to just calculate the derivatives directly (at least for the derivatives). For those we have

and

This multiplication takes a vector in the plane and rotates it 90 degrees, leaving an inwards facing radial unit vector in the x,y plane.

Now, having worked out the commutator method, lets at least verify that it works.

Much harder this way compared to taking the derivative directly, but we at least get the right answer. For the derivative using the commutator we have

Good, also consistent with direct calculation. How about our derivatives? Lets just calculate these directly without bothering at all with the commutator. This is

and

Finally, last we have the derivatives of . Those are

and

Summarizing, all the derivatives we need to evaluate the square of the angular momentum operator are

Bugger. We actually want the derivatives of the bivectors and so we aren’t ready to evaluate the squared angular momentum. There’s three choices, one is to use these results and apply the chain rule, or start over and directly take the derivatives of these bivectors, or use the commutator result (which didn’t actually assume vectors and we can apply it to bivectors too if we really wanted to).

An attempt to use the chain rule get messy, but it looks like the bivectors reduce nicely, making it pointless to even think about the commutator method. Introducing some notational conveniences, first write . We’ll have to be a bit careful with this since it commutes with , but anticommutes with or (and therefore ). As usual we also write for the Euclidean pseudoscalar (which commutes with all vectors and bivectors).

This gives us just

and calculation of the bivector partials will follow exclusively from the partials tabulated above.

Our other bivector doesn’t reduce quite as cleanly. We have

So for this one we have

Tabulating all the bivector derivatives (details omitted) we have

Okay, we are now armed to do the squaring of the angular momentum, but once again it’s late to start now. To be continued.

perl regex tricks. Non capturing expressions and alternatives.

Have two sets of dump output to compare, and both have the occasional pointer dumped which messes up the diff. I want to mask the pointer output (all starting with 0x) on all the lines like:

 List Entry Address:           0x...
 List Tail (primary):             0x...
 List Tail (secondary):           0x...
 Next entry name collision:    0x...
 Next entry PLEID collision:   0x...
 Next entry (primary):         0x...
 Next entry (secondary):       0x...
 Previous entry (primary):     0x...
 Previous entry (secondary):   0x...

An easy way would be to run ‘grep -v’ and just filter these out completely, but I wanted the original line numbers to stay intact for reference.

Here’s a one liner perl script, executed with ‘perl -pi ./myScript *.fmt’ (where the files *.fmt are what I’m mucking with) :

$ cat myScript
s/((?i:Next|List|previous) (?i:entry|head|tail).*0x).*/$1................/;

Since I had to lookup (man perlre) how to do this once again, it’s a good blog topic for self reference. Let’s break it down. First thing is an outermost capturing pattern

s/(stuff.*0x).*/$1................/;

this says match ‘stuff.*0x’, namely ‘stuff’ followed by anything (the .* part), then ’0x’, then anything. All of this within the braces goes into $1, so the replacement is everything on the line except whatever follows 0x (and for that I replaced with 16 dots). Now look at the nested expression before the .*0x part:

(?i:Next|List|previous) (?i:entry|head|tail)

More perl ASCII barf starting things off, but it’s not so bad. If you have an expression like (?:stuff) it means match ‘stuff’ but don’t capture it (i.e. don’t put it in $2 or $3, …). Only slightly more complex is having alternatives in the pattern, so something like (?:Next|List) means match Next or match List, but also don’t put anything into a $N variable. There’s one more bit in there unexplained, the ‘i’ modifier flag. This is a way to add case Insensitive to the pattern. In this case I could have made that a global flag at the end of the replace specification so it would apply to the whole pattern:

s/((?:Next|List|previous) (?:entry|head|tail).*0x).*/$1................/i;

but initially I had the case Insensitive modifier only on one of the patterns, so the final result ended up with some redundancy.