Dirac notation update

[certik]

Dirac notation is:

1. convenient way to handle vectors in Hilbert vector spaces, as shown here:

http://theoretical-physics.net/dev/src/math/la.html

Mathematically there is no problem at all, we are just using the Riesz representation theorem.

http://en.wikipedia.org/wiki/Riesz_representation_theorem

2. ways of dealing with different representations, e.g. f(x), f(x'), f(p) (fourier), and so on, as briefly described here:

http://theoretical-physics.net/dev/src/math/other.html#dirac-notation

however, it should be expanded and more examples added. It should be stressed, that |f> is a vector, that can be represented in any basis (|x>, |x'>, |p>, |n>, ...) and Dirac notation provides unified ways of dealing with it.

It is still independent of the scalar product, and so 1) and 2) should be unified somehow.

In particular \int |x><x| dx = 1 only holds if we use the L2 scalar product. For weighted L2 product, we'll get \int w(x) * |x><x| dx = 1, and so on. For H1, it gets more nasty.

We need to put there easy way to derive these formulas and show what follows from what.

[certik]

Another idea to put in:

section 1) only has bases that are infinite, but countable, e.g. |0>, |1>, ...., and if we sum all of it:

sum_i=0^oo |i><i| = 1

but we sum only from 0..n, we get the projection operator to the subspace spanned by |0>, .., |n>:

sum_i=0^n |i><i| = P

such bases are for example fourier series, states of the hydrogen atom and other things. It would be cool to put there lots of examples.

As far as I know, this is just regular Hilbert space, no problems.

Section 2) on the other hand has infinite, uncountable bases, with the property:

\int |x><x| = 1

we need to integrate over them. Examples are "x", Fourier transformation and other things.

[certik]

2. is a formal thing, but it works. Maybe I should think about 1) first, as that it is actually a different way of writing known things.

<i|j> = \delta_ij

does it imply \sum |i><i| = 1 and so on. What follows from what. Also 1) is completely scalar product independent.

I think that 2) is scalar product dependent.

1. only contains normalizable vectors, while 2) non-normalizable, things like e^{ix} and so on.

pretty good explanation is at:

http://en.wikipedia.org/wiki/Bra-ket_notation

so 1) is just regular Hilbert space, no problem.

2. is a so called rigged Hilbert space:

http://en.wikipedia.org/wiki/Rigged_Hilbert_space

[certik]

Good notes are here:

http://bohr.physics.berkeley.edu/classes/221/0708/notes/hilbert.pdf

[certik]

Also in the examples here:

http://theoretical-physics.net/dev/src/math/la.html

change |f> to <x|f> and simply do things properly.

[certik]

Add section about operators, spectrum and so on, and lots of examples. i*d/dx, on finite interval (fourier series), infinite interval (fourier transform) and so on.

Write an intro, that a function "f" can be defined using values f(x), or coefficients of a fourier series f_k, coefficients of legendre polynomials f_n, or coefficients of a fourier transform f(k). In all those cases, it is still the same function "f", no matter which representation we use.

|x> are eigenvectors of the operator X, thus <x|f> are coefficients with respect to x

[certik]

Introduce the level 1), and do lots of examples, because that is the level that sometimes is sufficient. Show that |f> != f(x), however, there is one to one correspondence between |f> and f(x), and as such, let's write maybe |f> <--> f(x), to show that those objects are not the same, but can be mapped to each other. Show that the correct way of writing it is by <x|f> = f(x).

Unify the LA stuff with this and work it out in sympy.

Introduce level 2), give the motivation and introduce operators X, P, and some other, lots of examples (preferably in sympy, if possible), and show that everything nicely fits together.