boost {lorentz}R Documentation

Lorentz transformations

Description

Lorentz transformations: boosts and rotations

Usage

boost(u=0)
rot(u,v,space=TRUE)
is.consistent.boost(L, give=FALSE, TOL=1e-10)
is.consistent.boost.galilean(L, give=FALSE, TOL=1e-10)
pureboost(L,include_sol=TRUE)
orthog(L)
pureboost.galilean(L, tidy=TRUE)
orthog.galilean(L)

Arguments

u, v

Three-velocities, coerced to class 3vel. In function boost(), if u takes the special default value 0, this is interpreted as zero three velocity

L

Lorentz transform expressed as a 4\times 4 matrix

TOL

Numerical tolerance

give

Boolean with TRUE meaning to return the transformed metric tensor (which should be the flat-space eta(); qv) and default FALSE meaning to return whether the matrix is a consistent boost or not

space

Boolean, with default TRUE meaning to return just the spatial component of the rotation matrix and FALSE meaning to return the full 4\times 4 matrix transformation

tidy

In pureboost.galilean(), Boolean with default TRUE meaning to return a “tidy” boost matrix with spatial components forced to be a 3\times 3 identity matrix

include_sol

In function pureboost(), Boolean with default TRUE meaning to correctly account for the speed of light, and FALSE meaning to assume c=1. See details

Details

Arguments u,v are coerced to three-velocities.

A rotation-free Lorentz transformation is known as a boost (sometimes a pure boost), here expressed in matrix form. Pure boost matrices are symmetric if c=1. Function boost(u) returns a 4\times 4 matrix giving the Lorentz transform of an arbitrary three-velocity u.

Boosts can be successively applied with regular matrix multiplication. However, composing two successive pure boosts does not in general return a pure boost matrix: the product is not symmetric in general. Also note that boost matrices do not commute. The resulting matrix product represents a Lorentz transform.

It is possible to decompose a Lorentz transform L into a pure boost and a spatial rotation. Thus L=OP where O is an orthogonal matrix and P a pure boost matrix; these are returned by functions orthog() and pureboost() respectively. If the speed of light is not equal to 1, the functions still work but can be confusing.

Functions pureboost.galilean() and orthog.galilean() are the Newtonian equivalents of pureboost() and orthog(), intended to be used when the speed of light is infinite (which causes problems for the relativistic functions).

As noted above, the composition of two pure Lorentz boosts is not necessarily pure. If we have two successive boosts corresponding to u and v, then the composed boost may be decomposed into a pure boost of boost(u+v) and a rotation of rot(u,v).

The reason argument include_sol exists is that function orthog() needs to call pureboost() in an environment where we pretend that c=1.

Value

Function boost() returns a 4\times 4 matrix; function rot() returns an orthogonal matrix.

Note

Function rot() uses crossprod() for efficiency reasons but is algebraically equivalent to

boost(-u-v) %*% boost(u) %*% boost(v).

Author(s)

Robin K. S. Hankin

References

Examples

boost(as.3vel(c(0.4,-0.2,0.1)))

u <- r3vel(1)
v <- r3vel(1)
w <- r3vel(1)

boost(u) - solve(boost(-u))  # should be zero

boost(u) %*% boost(v)   # not a pure boost (not symmetrical)
boost(u+v)  # not the same!
boost(v+u)  # also not the same!

u+v  # returns a three-velocity


boost(u) %*% boost(v) %*% boost(w)  # associative, no brackets needed
boost(u+(v+w))  # not the same!
boost((u+v)+w)  # also not the same!


rot(u,v)
rot(v,u)    # transpose (=inverse) of rot(u,v)


rot(u,v,FALSE) %*% boost(v) %*% boost(u)
boost(u+v)     # should be the same.


orthog(boost(u) %*% boost(v)) - rot(u,v,FALSE)  # zero to numerical precision
pureboost(boost(v) %*% boost(u)) - boost(u+v)   # ditto


## Define a random-ish Lorentz transform
L <- boost(r3vel(1)) %*% boost(r3vel(1)) %*% boost(r3vel(1))

## check it:


## Not run:    # needs emulator package
quad.form(eta(),L)  # should be eta()

## End(Not run)

## More concisely:
is.consistent.boost(L)     # should be TRUE

## Decompose L into a rotation and a pure boost:
U <- orthog(L)
P <- pureboost(L)

L - U %*% P              # should be zero (L = UP)
crossprod(U)               # should be identity (U is orthogonal)
P - t(P)                   # should be zero (P is symmetric)

## First row of P should be a consistent 4-velocity:
is.consistent.4vel(P[1,,drop=FALSE],give=TRUE)
[Package lorentz version 1.1-1 Index]