lorentz (version 1.0-2)

boost: Lorentz transformations

Description

Lorenz transformations: boosts and rotations

Usage

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

Arguments

u,v

Three-velocities, coerced to class 3vel

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

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

Value

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

Details

Arguments u,v are coerced to three-velocities.

A rotation-free Lorentz transformation is known as a boost (sometimes a pure boost), and when expressed in matrix form is symmetric. Function boost(u) returns a \(4\times 4\) matrix giving the Lorentz transform of an arbitrary three-velocity u. Pure boost matrices are symmetrical, but do not commute in general.

Boosts can be successively applied with regular matrix multiplication. However, composing two successive pure boosts does not return a pure boost matrix: the product is not symmetric in general. The resulting matrix 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.

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\).

References

• Ungar 2006. “Thomas precession: a kinematic effect…”. European Journal of Physics, 27:L17-L20

• Sbitneva 2001. “Nonassociative geometry of special relativity”. International Journal of Theoretical Physics, volume 40, number 1, pages 359--362

• Wikipedia contributors 2018. “Wigner rotation”, Wikipedia, The Free Encyclopedia. https://en.wikipedia.org/w/index.php?title=Wigner_rotation&oldid=838661305. Online; accessed 23 August 2018

Examples

# NOT RUN {
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)  # should be small
pureboost(boost(v) %*% boost(u)) - boost(u+v)   # should be small


## 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()
# }
# 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 small (L = UP)
crossprod(U)               # should be identity (U is orthogonal)
P - t(P)                   # should be small (P is symmetric)

## First row of P should be a consistent 4-velocity:
is.consistent.4vel(as.4vel(P[,1]))



# }