Physics[`.`]  scalar product between Bras, Kets, and quantum operators, and simplification of contracted indices in spacetime tensors

Calling Sequence


Bra(A, ...) . Ket(B, ...)
Q . Ket(B, ...)
Bra(A, ...) . Q
A[mu, ...] . B[mu,...]


Parameters


Ket(B, ...)



a Ket vector; represents the quantum state of a system in Dirac's notation

Bra(A, ...)



a Bra vector; represents the quantum state of a system in Dirac's notation

Q



a quantum operator, set to be so by the Setup command, assumed to be a linear functional operator regarding Bras and Kets

A, B



both A and B a spacetime tensors defined as such with the Define command of the Physics package; to perform a simplification of the contracted (repeated) indices.





Description


•

The Physics[`.`] command is a computational representation for the scalar product operation between Bras, Kets, and quantum operators set to be so by the Setup command, or returned by the Annihilation, Creation, and Projector commands.

•

Independent of that, Physics[`.`] is also a handy shortcut for performing simplification of contracted indices in tensor products; for instance if A[mu] is Defined as a tensor, g_[mu, nu] . A[nu] returns A[mu], equivalent to performing Simplify(g_[mu, nu] * A[nu], indices) (see Simplify and the end of the Examples section).

•

When taking the scalar product between Bras, Kets, or quantum operator, generally speaking, two situations can happen: 1) there is not enough information to perform the operation (for example, for two generic unknown Kets), in which case it is returned unevaluated; or 2) the information available permits performing the operation.

•

In the following situations, the scalar product is returned unevaluated:


 A product involving only a quantum operator and either a Ket or a Bra is returned as entered, in terms of Physics[`.`].


 A product with two or more Kets only (or two or more Bras only) is returned in terms of Physics[*], and represents a statevector of the tensor product of the respective spaces.

•

In the following situations, the scalar product can be performed:


 The Kets belong to the same basis: if the basis, represented by the Ket's first argument, is discrete, then the result involves KroneckerDelta; if the basis is continuous, then it involves the Dirac function. To indicate that a basis is continuous, use the Setup command. Remark: when the discrete or continuous character of the basis has not been set, it is assumed that the basis is discrete.



Examples


>


>


 (1) 
When there is not enough information to perform the scalar product, the result is returned unevaluated, depending on the case, in terms of the Bracket function.
>


 (2) 
>


 (3) 
>


 (4) 
When the Bra and Ket belong to the same basis, unless this basis is specified as a continuous basis by the Setup command, it is assumed that the basis is discrete, and the scalar product is returned in terms of KroneckerDelta.
>


 (5) 
>


 (6) 
>


 (7) 
In the output above, you see a Dirac delta function. If, in , the symbol does not represent a quantum operator, the operation is transformed into a commutative or noncommutative product, according to whether or not is commutative. If has been set to represent a quantum operator, or was returned as such by the Annihilation or Creation commands, then is applied to the Ket as follows:
>


 (8) 
>


 (9) 
>


 (10) 
Kets using as a label (first argument) are eigenvectors of the operator ; to identify the quantum number entered as an eigenvalue, indicate its position as an index to the operator .
>


 (11) 
>


 (12) 
Note that there is an inert form for the scalar product operation, represented, as in the case of the other Physics commands, by the operator preceded by %. The inert form is activated by using the value command.
>


 (13) 
>


 (14) 
By setting the bracket rules, you can also control the result of the corresponding scalar products; note the use of the default abbreviation for KroneckerDelta.
>


 (15) 
>


 (16) 
>


 (17) 
>


 (18) 
>


 (19) 
Note that the implementation of Physics[`.`] is that of an overloaded procedure. Thus if the arguments are not of type algebraic, for example, if they are of type Matrix, and other related packages are loaded, then the operation is automatically forwarded to these other packages. The same happens if you load the Vectors subpackage of Physics, which has its own scalar product operator, which is also implemented as an overloaded procedure. So provided that Physics or Physics[Vectors] is loaded last, these packages can be loaded together with everything working as expected.
For example, load the VectorCalculus and Physics[Vectors] packages to work with Matrix and algebraic representations of vectors, respectively.
>


>


Try performing the operations between Bra and Ket vectors belonging to spaces of quantum states: everything continues working.
>


 (20) 
>


 (21) 
>


 (22) 
Now the symbols and are algebraic representations for vectors because you loaded the Vectors package, so the following operation is automatically forwarded to be performed by that package.
Scalar product between 3D nonprojected vectors:
>


 (23) 
Algebraic sum:
>


 (24) 
>


>


 (25) 
>


 (26) 
In the next example, and are Matrix representation of vectors because you loaded the VectorCalculus package. This operation is automatically forwarded to be performed by that package's subroutines.
is not an algebraic object:
>


 (27) 
>


Vector[row](3, {1 = 1, 2 = 2, 3 = 3}, datatype = anything, storage = rectangular, order = Fortran_order, attributes = [coords = cartesian], shape = [])
 
>


 (28) 
>


 (29) 
The Physics[`.`] operator is also a handy shortcut for performing simplification of contracted indices in tensor products. Define first some spacetime tensors.
>


 (30) 
Compare the difference between `*` and `.`
>


 (31) 
>


 (32) 
So is g_[alpha, mu] . A[mu] equivalent to Simplify(g_[alpha, mu] * A[mu], indices). This functionality is particularly useful when handling larger expressions where you want contraction to be simplified only in some places. Consider the following product
>


 (33) 
You can always Simplify the whole product, as in
>


 (34) 
Using Physics[`.`], however, you can achieve either the same, or any more selective simplification. Replacing the first `*` by `.`,
>


 (35) 
Likely (note the parenthesis to indicate the desired order of precedence between `.` and `*`)
>


 (36) 
and replacing `*` and `.` in the middle of the expression,
>


 (37) 
When one of the sides of `.` is a nested expression, the simplification of contracted indices is performed recursively, compare for instance
>


 (38) 
>


 (39) 
Set the spacetime metric to be the Schwarzschild metric and consider the contraction of all the indices of the Riemann tensor
>


 (40) 
>


 (41) 
>


 (42) 
>




See Also


`*`, Bra, Bracket, Define, g_, Ket, lprint, Physics, Physics conventions, Physics examples, Physics[Vectors], Riemann, Setup, Simplify, VectorCalculus


References



CohenTannoudji, C.; Diu, B.; and Laloe, F. Quantum Mechanics. Chapter II. Paris, France: Hermann, 1977.


