ecterrab

11508 Reputation

24 Badges

17 years, 42 days

MaplePrimes Activity


These are Posts that have been published by ecterrab

Following the previous post on The Electromagnetic Field of Moving Charges, this is another non-trivial exercise, the derivation of 4-dimensional relativistic Lorentz transformations,  a problem of a 3rd-year undergraduate course on Special Relativity whose solution requires "tensor & matrix" manipulation techniques. At the end, there is a link to the Maple document, so that the computation below can be reproduced, and a link to a corresponding PDF file with all the sections open.

Deriving 4D relativistic Lorentz transformations

Freddy Baudine(1), Edgardo S. Cheb-Terrab(2)

(1) Retired, passionate about Mathematics and Physics

(2) Physics, Differential Equations and Mathematical Functions, Maplesoft

 

Lorentz transformations are a six-parameter family of linear transformations Lambda that relate the values of the coordinates x, y, z, t of an event in one inertial reference system to the coordinates diff(x, x), diff(y(x), x), diff(z(x), x), diff(t(x), x) of the same event in another inertial system that moves at a constant velocity relative to the former. An explicit form of Lambda can be derived from physics principles, or in a purely algebraic mathematical manner. A derivation from physics principles is done in an upcoming post about relativistic dynamics, while in this post we derive the form of Lambda mathematically, as rotations in a (pseudo) Euclidean 4 dimensional space. Most of the presentation below follows the one found in Jackson's book on Classical Electrodynamics [1].

 

The computations below in Maple 2022 make use of the Maplesoft Physics Updates v.1283 or newer.

Formulation of the problem and ansatz Lambda = exp(`𝕃`)

 

 

The problem is to find a group of linear transformations,

  "x^(' mu)=(Lambda^( mu))[nu]  x^(nu)" 

that represent rotations in a 4D (pseudo) Euclidean spacetime, and so they leave invariant the norm of the 4D position vector x^mu; that is,

"x^(' mu) (x')[mu]=x^( mu) (x^())[mu]"

For the purpose of deriving the form of `#msubsup(mi("Λ",fontstyle = "normal"),mi("ν",fontstyle = "normal"),mrow(mo("⁢"),mi("μ",fontstyle = "normal")))`, a relevant property for it can be inferred by rewriting the invariance of the norm in terms of `#msubsup(mi("Λ",fontstyle = "normal"),mi("ν",fontstyle = "normal"),mrow(mo("⁢"),mi("μ",fontstyle = "normal")))`. In steps, from the above,

"g[alpha,beta] x^(' alpha) (x^(' beta))[]=g[mu,nu] x^( mu) (x^( nu))[]"
 

g[alpha, beta]*`#msubsup(mi("Λ",fontstyle = "normal"),mi("μ",fontstyle = "normal"),mrow(mo("⁢"),mi("α",fontstyle = "normal")))`*x^mu*`#msubsup(mi("Λ",fontstyle = "normal"),mi("ν",fontstyle = "normal"),mrow(mo("⁢"),mi("β",fontstyle = "normal")))`*x^nu = g[mu, nu]*x^mu*`#msup(mi("x"),mrow(mo("⁢"),mi("ν",fontstyle = "normal")))`
 

g[alpha, beta]*`#msubsup(mi("Λ",fontstyle = "normal"),mi("μ",fontstyle = "normal"),mrow(mo("⁢"),mi("α",fontstyle = "normal")))`*x^mu*`#msubsup(mi("Λ",fontstyle = "normal"),mi("ν",fontstyle = "normal"),mrow(mo("⁢"),mi("β",fontstyle = "normal")))`*x^nu = g[mu, nu]*x^mu*`#msup(mi("x"),mrow(mo("⁢"),mi("ν",fontstyle = "normal")))`

from where,

g[alpha, beta]*`#msubsup(mi("Λ",fontstyle = "normal"),mi("μ",fontstyle = "normal"),mrow(mo("⁢"),mi("α",fontstyle = "normal")))`*`#msubsup(mi("Λ",fontstyle = "normal"),mi("ν",fontstyle = "normal"),mrow(mo("⁢"),mi("β",fontstyle = "normal")))` = g[mu, nu]``

or in matrix (4 x 4) form, `#mrow(msubsup(mi("Λ",fontstyle = "normal"),mi("μ",fontstyle = "normal"),mrow(mo("⁢"),mi("α",fontstyle = "normal"))),mo("⁢"),mo("≡"),mo("⁢"),mo("⁢"),mi("Λ",fontstyle = "normal"))`, `≡`(g[alpha, beta], g)

Lambda^T*g*Lambda = g

where Lambda^T is the transpose of Lambda. Taking the determinant of both sides of this equation, and recalling that det(Lambda^T) = det(Lambda), we get

 

det(Lambda) = `&+-`(1)

 

The determination of Lambda is analogous to the determination of the matrix R (3D tensor R[i, j]) representing rotations in the 3D space, where the same line of reasoning leads to det(R) = `&+-`(1). To exclude reflection transformations, that have det(Lambda) = -1 and cannot be obtained through any sequence of rotations, because they do not preserve the relative orientation of the axes, the sign that represents our problem is +. To explicitly construct the transformation matrix Lambda, Jackson proposes the ansatz

  Lambda = exp(`𝕃`)   

Summarizing: the determination of `#msubsup(mi("Λ",fontstyle = "normal"),mi("ν",fontstyle = "normal"),mrow(mo("⁢"),mi("μ",fontstyle = "normal")))` consists of determining `𝕃`[nu]^mu entering Lambda = exp(`𝕃`) such that det(Lambda) = 1followed by computing the exponential of the matrix `𝕃`.

Determination of `𝕃`[nu]^mu

 

In order to compare results with Jackson's book, we use the same signature he uses, "(+---)", and lowercase Latin letters to represent space tensor indices, while spacetime indices are represented using Greek letters, which is already Physics' default.

 

restart; with(Physics)

Setup(signature = "+---", spaceindices = lowercaselatin)

[signature = `+ - - -`, spaceindices = lowercaselatin]

(1)

Start by defining the tensor `𝕃`[nu]^mu whose components are to be determined. For practical purposes, define a macro LM = `𝕃` to represent the tensor and use L to represent its components

macro(LM = `𝕃`, %LM = `%𝕃`); Define(Lambda, LM, quiet)

LM[`~mu`, nu] = Matrix(4, symbol = L)

`𝕃`[`~mu`, nu] = Matrix(%id = 36893488153289603060)

(2)

"Define(?)"

{Lambda, `𝕃`[`~mu`, nu], Physics:-Dgamma[mu], Physics:-Psigma[mu], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-gamma_[a, b], Physics:-LeviCivita[alpha, beta, mu, nu]}

(3)

Next, from Lambda^T*g*Lambda = g (see above in Formulation of the problem) one can derive the form of `𝕃`. To work algebraically with `𝕃`, Lambda, g representing matrices, set these symbols as noncommutative

Setup(noncommutativeprefix = {LM, Lambda, g})

[noncommutativeprefix = {`𝕃`, Lambda, g}]

(4)

From

Lambda^T*g*Lambda = g

Physics:-`*`(Physics:-`^`(Lambda, T), g, Lambda) = g

(5)

it follows that

(1/g*(Physics[`*`](Physics[`^`](Lambda, T), g, Lambda) = g))/Lambda

Physics:-`*`(Physics:-`^`(g, -1), Physics:-`^`(Lambda, T), g) = Physics:-`^`(Lambda, -1)

(6)

eval(Physics[`*`](Physics[`^`](g, -1), Physics[`^`](Lambda, T), g) = Physics[`^`](Lambda, -1), Lambda = exp(LM))

Physics:-`*`(Physics:-`^`(g, -1), Physics:-`^`(exp(`𝕃`), T), g) = Physics:-`^`(exp(`𝕃`), -1)

(7)

Expanding the exponential using exp(`𝕃`) = Sum(`𝕃`^k/factorial(k), k = 0 .. infinity), and taking into account that the matrix product `𝕃`^k/g*g can be rewritten as(`𝕃`/g*g)^k, the left-hand side of (7) can be written as exp(`𝕃`^T/g*g)

exp(LM^T/g*g) = rhs(Physics[`*`](Physics[`^`](g, -1), Physics[`^`](exp(`𝕃`), T), g) = Physics[`^`](exp(`𝕃`), -1))

exp(Physics:-`*`(Physics:-`^`(g, -1), Physics:-`^`(`𝕃`, T), g)) = Physics:-`^`(exp(`𝕃`), -1)

(8)

Multiplying by exp(`𝕃`)

(exp(Physics[`*`](Physics[`^`](g, -1), Physics[`^`](`𝕃`, T), g)) = Physics[`^`](exp(`𝕃`), -1))*exp(LM)

Physics:-`*`(exp(Physics:-`*`(Physics:-`^`(g, -1), Physics:-`^`(`𝕃`, T), g)), exp(`𝕃`)) = 1

(9)

Recalling that  "g^(-1)=g[]^(mu,alpha)", g = g[beta, nu] and that for any matrix `𝕃`, "(`𝕃`^T)[alpha]^(   beta)= `𝕃`(( )^(beta))[alpha]",  

"g^(-1) `𝕃`^T g= 'g_[~mu,~alpha]*LM[~beta, alpha] g_[beta, nu] '"

Physics:-`*`(Physics:-`^`(g, -1), Physics:-`^`(`𝕃`, T), g) = Physics:-`*`(Physics:-g_[`~mu`, `~alpha`], `𝕃`[`~beta`, alpha], Physics:-g_[beta, nu])

(10)

subs([Physics[`*`](Physics[`^`](g, -1), Physics[`^`](`𝕃`, T), g) = Physics[`*`](Physics[g_][`~mu`, `~alpha`], `𝕃`[`~beta`, alpha], Physics[g_][beta, nu]), LM = LM[`~mu`, nu]], Physics[`*`](exp(Physics[`*`](Physics[`^`](g, -1), Physics[`^`](`𝕃`, T), g)), exp(`𝕃`)) = 1)

Physics:-`*`(exp(Physics:-g_[`~alpha`, `~mu`]*Physics:-g_[beta, nu]*`𝕃`[`~beta`, alpha]), exp(`𝕃`[`~mu`, nu])) = 1

(11)

To allow for the combination of the exponentials, now that everything is in tensor notation, remove the noncommutative character of `𝕃```

Setup(clear, noncommutativeprefix)

[noncommutativeprefix = none]

(12)

combine(Physics[`*`](exp(Physics[g_][`~alpha`, `~mu`]*Physics[g_][beta, nu]*`𝕃`[`~beta`, alpha]), exp(`𝕃`[`~mu`, nu])) = 1)

exp(`𝕃`[`~beta`, alpha]*Physics:-g_[beta, nu]*Physics:-g_[`~alpha`, `~mu`]+`𝕃`[`~mu`, nu]) = 1

(13)

Since every tensor component of this expression is real, taking the logarithm at both sides and simplifying tensor indices

`assuming`([map(ln, exp(`𝕃`[`~beta`, alpha]*Physics[g_][beta, nu]*Physics[g_][`~alpha`, `~mu`]+`𝕃`[`~mu`, nu]) = 1)], [real])

`𝕃`[`~beta`, alpha]*Physics:-g_[beta, nu]*Physics:-g_[`~alpha`, `~mu`]+`𝕃`[`~mu`, nu] = 0

(14)

Simplify(`𝕃`[`~beta`, alpha]*Physics[g_][beta, nu]*Physics[g_][`~alpha`, `~mu`]+`𝕃`[`~mu`, nu] = 0)

`𝕃`[nu, `~mu`]+`𝕃`[`~mu`, nu] = 0

(15)

So the components of `𝕃`[`~mu`, nu]

LM[`~μ`, nu, matrix]

`𝕃`[`~μ`, nu] = Matrix(%id = 36893488151939882148)

(16)

satisfy (15). Using TensorArray  the components of that tensorial equation are

TensorArray(`𝕃`[nu, `~mu`]+`𝕃`[`~mu`, nu] = 0, output = setofequations)

{2*L[1, 1] = 0, 2*L[2, 2] = 0, 2*L[3, 3] = 0, 2*L[4, 4] = 0, -L[1, 2]+L[2, 1] = 0, L[1, 2]-L[2, 1] = 0, -L[1, 3]+L[3, 1] = 0, L[1, 3]-L[3, 1] = 0, -L[1, 4]+L[4, 1] = 0, L[1, 4]-L[4, 1] = 0, L[3, 2]+L[2, 3] = 0, L[4, 2]+L[2, 4] = 0, L[4, 3]+L[3, 4] = 0}

(17)

Simplifying taking these equations into account results in the form of `𝕃`[`~mu`, nu] we were looking for

"simplify(?,{2*L[1,1] = 0, 2*L[2,2] = 0, 2*L[3,3] = 0, 2*L[4,4] = 0, -L[1,2]+L[2,1] = 0, L[1,2]-L[2,1] = 0, -L[1,3]+L[3,1] = 0, L[1,3]-L[3,1] = 0, -L[1,4]+L[4,1] = 0, L[1,4]-L[4,1] = 0, L[3,2]+L[2,3] = 0, L[4,2]+L[2,4] = 0, L[4,3]+L[3,4] = 0})"

`𝕃`[`~μ`, nu] = Matrix(%id = 36893488153606736460)

(18)

This is equation (11.90) in Jackson's book [1]. By eye we see there are only six independent parameters in `𝕃`[`~mu`, nu], or via

"indets(rhs(?), name)"

{L[1, 2], L[1, 3], L[1, 4], L[2, 3], L[2, 4], L[3, 4]}

(19)

nops({L[1, 2], L[1, 3], L[1, 4], L[2, 3], L[2, 4], L[3, 4]})

6

(20)

This number is expected: a rotation in 3D space can always be represented as the composition of three rotations, and so, characterized by 3 parameters: the rotation angles measured on each of the space planes x, y, y, z, z, x. Likewise, a rotation in 4D space is characterized by 6 parameters: rotations on each of the three space planes, parameters L[2, 3], L[2, 4] and L[3, 4],  and rotations on the spacetime planest, x, t, y, t, z, parameters L[1, j]. Define now `𝕃`[`~mu`, nu] using (18) for further computing with it in the next section

"Define(?)"

{Lambda, `𝕃`[`~mu`, nu], Physics:-Dgamma[mu], Physics:-Psigma[mu], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-gamma_[a, b], Physics:-LeviCivita[alpha, beta, mu, nu]}

(21)

Determination of Lambda[`~mu`, nu]

 

From the components of `𝕃`[`~mu`, nu] in (18), the components of Lambda[`~mu`, nu] = exp(`𝕃`[`~mu`, nu]) can be computed directly using the LinearAlgebra:-MatrixExponential command. Then, following Jackson's book, in what follows we also derive a general formula for `𝕃`[`~mu`, nu]in terms of beta = v/c and gamma = 1/sqrt(-beta^2+1) shown in [1] as equation (11.98), finally showing the form of Lambda[`~mu`, nu] as a function of the relative velocity of the two inertial systems of references.

 

An explicit form of Lambda[`~mu`, nu] in the case of a rotation on thet, x plane can be computed by taking equal to zero all the parameters in (19) but for L[1, 2] and substituting in "?≡`𝕃`[nu]^(mu)"  

`~`[`=`](`minus`({L[1, 2], L[1, 3], L[1, 4], L[2, 3], L[2, 4], L[3, 4]}, {L[1, 2]}), 0)

{L[1, 3] = 0, L[1, 4] = 0, L[2, 3] = 0, L[2, 4] = 0, L[3, 4] = 0}

(22)

"subs({L[1,3] = 0, L[1,4] = 0, L[2,3] = 0, L[2,4] = 0, L[3,4] = 0},?)"

`𝕃`[`~μ`, nu] = Matrix(%id = 36893488153606695500)

(23)

Computing the matrix exponential,

"Lambda[~mu,nu]=LinearAlgebra:-MatrixExponential(rhs(?))"

Lambda[`~μ`, nu] = Matrix(%id = 36893488151918824492)

(24)

"convert(?,trigh)"

Lambda[`~μ`, nu] = Matrix(%id = 36893488151918852684)

(25)

This is formula (4.2) in Landau & Lifshitz book [2]. An explicit form of Lambda[`~mu`, nu] in the case of a rotation on thex, y plane can be computed by taking equal to zero all the parameters in (19) but for L[2, 3]

`~`[`=`](`minus`({L[1, 2], L[1, 3], L[1, 4], L[2, 3], L[2, 4], L[3, 4]}, {L[2, 3]}), 0)

{L[1, 2] = 0, L[1, 3] = 0, L[1, 4] = 0, L[2, 4] = 0, L[3, 4] = 0}

(26)

"subs({L[1,2] = 0, L[1,3] = 0, L[1,4] = 0, L[2,4] = 0, L[3,4] = 0},?)"

`𝕃`[`~μ`, nu] = Matrix(%id = 36893488151918868828)

(27)

"Lambda[~mu, nu]=LinearAlgebra:-MatrixExponential(rhs(?))"

Lambda[`~μ`, nu] = Matrix(%id = 36893488153289306948)

(28)

NULL

Rewriting `%𝕃`[`~mu`, nu] = K[`~i`]*Zeta[i]+S[`~i`]*omega[i]

 

Following Jackson's notation, for readability, redefine the 6 parameters entering `𝕃`[`~mu`, nu] as

'{LM[1, 2] = `ζ__1`, LM[1, 3] = `ζ__2`, LM[1, 4] = `ζ__3`, LM[2, 3] = `ω__3`, LM[2, 4] = -`ω__2`, LM[3, 4] = `ω__1`}'

{`𝕃`[1, 2] = zeta__1, `𝕃`[1, 3] = zeta__2, `𝕃`[1, 4] = zeta__3, `𝕃`[2, 3] = omega__3, `𝕃`[2, 4] = -omega__2, `𝕃`[3, 4] = omega__1}

(29)

(Note in the above the surrounding backquotes '...' to prevent a premature evaluation of the left-hand sides; that is necessary when using the Library:-RedefineTensorComponent command.) With this redefinition, `𝕃`[`~mu`, nu] becomes

Library:-RedefineTensorComponent({`𝕃`[1, 2] = zeta__1, `𝕃`[1, 3] = zeta__2, `𝕃`[1, 4] = zeta__3, `𝕃`[2, 3] = omega__3, `𝕃`[2, 4] = -omega__2, `𝕃`[3, 4] = omega__1})

LM[`~μ`, nu, matrix]

`𝕃`[`~μ`, nu] = Matrix(%id = 36893488151939901668)

(30)

where each parameter is related to a rotation angle on one plane. Any Lorentz transformation (rotation in 4D pseudo-Euclidean space) can be represented as the composition of these six rotations, and to each rotation, corresponds the matrix that results from taking equal to zero all of the six parameters but one.

 

The set of six parameters can be split into two sets of three parameters each, one representing rotations on the t, x__j planes, parameters `ζ__j`, and the other representing rotations on the x__i, x__j planes, parameters `ω__j`. With that, following [1], (30) can be rewritten in terms of four 3D tensors, two of them with the parameters as components, the other two with matrix as components, as follows:

Zeta[i] = [`ζ__1`, `ζ__2`, `ζ__3`], omega[i] = [`ω__1`, `ω__2`, `ω__3`], K[i] = [K__1, K__2, K__3], S[i] = [S__1, S__2, S__3]

Zeta[i] = [zeta__1, zeta__2, zeta__3], omega[i] = [omega__1, omega__2, omega__3], K[i] = [K__1, K__2, K__3], S[i] = [S__1, S__2, S__3]

(31)

Define(Zeta[i] = [zeta__1, zeta__2, zeta__3], omega[i] = [omega__1, omega__2, omega__3], K[i] = [K__1, K__2, K__3], S[i] = [S__1, S__2, S__3])

{Lambda, `𝕃`[mu, nu], Physics:-Dgamma[mu], K[i], Physics:-Psigma[mu], S[i], Zeta[i], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-gamma_[a, b], omega[i], Physics:-LeviCivita[alpha, beta, mu, nu]}

(32)

The 3D tensors K[i] and S[i] satisfy the commutation relations

Setup(noncommutativeprefix = {K, S})

[noncommutativeprefix = {K, S}]

(33)

Commutator(S[i], S[j]) = LeviCivita[i, j, k]*S[k]

Physics:-Commutator(S[i], S[j]) = Physics:-LeviCivita[i, j, k]*S[`~k`]

(34)

Commutator(S[i], K[j]) = LeviCivita[i, j, k]*K[k]

Physics:-Commutator(S[i], K[j]) = Physics:-LeviCivita[i, j, k]*K[`~k`]

(35)

Commutator(K[i], K[j]) = -LeviCivita[i, j, k]*S[k]

Physics:-Commutator(K[i], K[j]) = -Physics:-LeviCivita[i, j, k]*S[`~k`]

(36)

The matrix components of the 3D tensor K__i, related to rotations on the t, x__j planes, are

K__1 := matrix([[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])

array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (0), ( 4, 2 ) = (0), ( 1, 2 ) = (1), ( 3, 2 ) = (0), ( 1, 3 ) = (0), ( 4, 3 ) = (0), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (1), ( 3, 3 ) = (0), ( 2, 4 ) = (0), ( 1, 4 ) = (0), ( 2, 2 ) = (0), ( 2, 3 ) = (0), ( 4, 1 ) = (0), ( 3, 4 ) = (0)  ] )

(37)

K__2 := matrix([[0, 0, 1, 0], [0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0]])

array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (1), ( 4, 2 ) = (0), ( 1, 2 ) = (0), ( 3, 2 ) = (0), ( 1, 3 ) = (1), ( 4, 3 ) = (0), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (0), ( 3, 3 ) = (0), ( 2, 4 ) = (0), ( 1, 4 ) = (0), ( 2, 2 ) = (0), ( 2, 3 ) = (0), ( 4, 1 ) = (0), ( 3, 4 ) = (0)  ] )

(38)

K__3 := matrix([[0, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0]])

array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (0), ( 4, 2 ) = (0), ( 1, 2 ) = (0), ( 3, 2 ) = (0), ( 1, 3 ) = (0), ( 4, 3 ) = (0), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (0), ( 3, 3 ) = (0), ( 2, 4 ) = (0), ( 1, 4 ) = (1), ( 2, 2 ) = (0), ( 2, 3 ) = (0), ( 4, 1 ) = (1), ( 3, 4 ) = (0)  ] )

(39)

The matrix components of the 3D tensor S__i, related to rotations on the x__i, x__j 3D space planes, are

S__1 := matrix([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, -1], [0, 0, 1, 0]])

array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (0), ( 4, 2 ) = (0), ( 1, 2 ) = (0), ( 3, 2 ) = (0), ( 1, 3 ) = (0), ( 4, 3 ) = (1), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (0), ( 3, 3 ) = (0), ( 2, 4 ) = (0), ( 1, 4 ) = (0), ( 2, 2 ) = (0), ( 2, 3 ) = (0), ( 4, 1 ) = (0), ( 3, 4 ) = (-1)  ] )

(40)

S__2 := matrix([[0, 0, 0, 0], [0, 0, 0, 1], [0, 0, 0, 0], [0, -1, 0, 0]])

array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (0), ( 4, 2 ) = (-1), ( 1, 2 ) = (0), ( 3, 2 ) = (0), ( 1, 3 ) = (0), ( 4, 3 ) = (0), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (0), ( 3, 3 ) = (0), ( 2, 4 ) = (1), ( 1, 4 ) = (0), ( 2, 2 ) = (0), ( 2, 3 ) = (0), ( 4, 1 ) = (0), ( 3, 4 ) = (0)  ] )

(41)

S__3 := matrix([[0, 0, 0, 0], [0, 0, -1, 0], [0, 1, 0, 0], [0, 0, 0, 0]])

array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (0), ( 4, 2 ) = (0), ( 1, 2 ) = (0), ( 3, 2 ) = (1), ( 1, 3 ) = (0), ( 4, 3 ) = (0), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (0), ( 3, 3 ) = (0), ( 2, 4 ) = (0), ( 1, 4 ) = (0), ( 2, 2 ) = (0), ( 2, 3 ) = (-1), ( 4, 1 ) = (0), ( 3, 4 ) = (0)  ] )

(42)

NULL

Verifying the commutation relations between S[i] and K[j]

   

The `𝕃`[`~mu`, nu] tensor is now expressed in terms of these objects as

%LM[`~μ`, nu] = omega[i].S[i]+Zeta[i].K[i]

`%𝕃`[`~μ`, nu] = K[`~i`]*Zeta[i]+S[`~i`]*omega[i]

(50)

where the right-hand side, without free indices, represents the matrix form of `%𝕃`[`~mu`, nu]. This notation makes explicit the fact that any Lorentz transformation can always be written as the composition of six rotations

SumOverRepeatedIndices(`%𝕃`[`~μ`, nu] = K[`~i`]*Zeta[i]+S[`~i`]*omega[i])

`%𝕃`[`~μ`, nu] = zeta__1*K[`~1`]+zeta__2*K[`~2`]+zeta__3*K[`~3`]+omega__1*S[`~1`]+omega__2*S[`~2`]+omega__3*S[`~3`]

(51)

Library:-RewriteInMatrixForm(`%𝕃`[`~μ`, nu] = zeta__1*K[`~1`]+zeta__2*K[`~2`]+zeta__3*K[`~3`]+omega__1*S[`~1`]+omega__2*S[`~2`]+omega__3*S[`~3`])

`%𝕃`[`~μ`, nu] = (array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (0), ( 4, 2 ) = (0), ( 1, 2 ) = (zeta__1), ( 3, 2 ) = (0), ( 1, 3 ) = (0), ( 4, 3 ) = (0), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (zeta__1), ( 3, 3 ) = (0), ( 2, 4 ) = (0), ( 1, 4 ) = (0), ( 2, 2 ) = (0), ( 2, 3 ) = (0), ( 4, 1 ) = (0), ( 3, 4 ) = (0)  ] ))+(array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (zeta__2), ( 4, 2 ) = (0), ( 1, 2 ) = (0), ( 3, 2 ) = (0), ( 1, 3 ) = (zeta__2), ( 4, 3 ) = (0), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (0), ( 3, 3 ) = (0), ( 2, 4 ) = (0), ( 1, 4 ) = (0), ( 2, 2 ) = (0), ( 2, 3 ) = (0), ( 4, 1 ) = (0), ( 3, 4 ) = (0)  ] ))+(array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (0), ( 4, 2 ) = (0), ( 1, 2 ) = (0), ( 3, 2 ) = (0), ( 1, 3 ) = (0), ( 4, 3 ) = (0), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (0), ( 3, 3 ) = (0), ( 2, 4 ) = (0), ( 1, 4 ) = (zeta__3), ( 2, 2 ) = (0), ( 2, 3 ) = (0), ( 4, 1 ) = (zeta__3), ( 3, 4 ) = (0)  ] ))+(array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (0), ( 4, 2 ) = (0), ( 1, 2 ) = (0), ( 3, 2 ) = (0), ( 1, 3 ) = (0), ( 4, 3 ) = (omega__1), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (0), ( 3, 3 ) = (0), ( 2, 4 ) = (0), ( 1, 4 ) = (0), ( 2, 2 ) = (0), ( 2, 3 ) = (0), ( 4, 1 ) = (0), ( 3, 4 ) = (-omega__1)  ] ))+(array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (0), ( 4, 2 ) = (-omega__2), ( 1, 2 ) = (0), ( 3, 2 ) = (0), ( 1, 3 ) = (0), ( 4, 3 ) = (0), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (0), ( 3, 3 ) = (0), ( 2, 4 ) = (omega__2), ( 1, 4 ) = (0), ( 2, 2 ) = (0), ( 2, 3 ) = (0), ( 4, 1 ) = (0), ( 3, 4 ) = (0)  ] ))+(array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (0), ( 4, 2 ) = (0), ( 1, 2 ) = (0), ( 3, 2 ) = (omega__3), ( 1, 3 ) = (0), ( 4, 3 ) = (0), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (0), ( 3, 3 ) = (0), ( 2, 4 ) = (0), ( 1, 4 ) = (0), ( 2, 2 ) = (0), ( 2, 3 ) = (-omega__3), ( 4, 1 ) = (0), ( 3, 4 ) = (0)  ] ))

(52)

Library:-PerformMatrixOperations(`%𝕃`[`~μ`, nu] = zeta__1*K[`~1`]+zeta__2*K[`~2`]+zeta__3*K[`~3`]+omega__1*S[`~1`]+omega__2*S[`~2`]+omega__3*S[`~3`])

`%𝕃`[`~μ`, nu] = (array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (zeta__2), ( 4, 2 ) = (-omega__2), ( 1, 2 ) = (zeta__1), ( 3, 2 ) = (omega__3), ( 1, 3 ) = (zeta__2), ( 4, 3 ) = (omega__1), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (zeta__1), ( 3, 3 ) = (0), ( 2, 4 ) = (omega__2), ( 1, 4 ) = (zeta__3), ( 2, 2 ) = (0), ( 2, 3 ) = (-omega__3), ( 4, 1 ) = (zeta__3), ( 3, 4 ) = (-omega__1)  ] ))

(53)

NULL

which is the same as the starting point (30)NULL

The transformation Lambda[`~mu`, nu] = exp(`%𝕃`[`~mu`, nu]), where  `%𝕃`[`~mu`, nu] = K[`~i`]*Zeta[i], as a function of the relative velocity of two inertial systems

 

 

As seen in the previous subsection, in `𝕃`[`~mu`, nu] = K[`~i`]*Zeta[i]+S[`~i`]*omega[i], the second term, S[`~i`]*omega[i], corresponds to 3D rotations embedded in the general form of 4D Lorentz transformations, and K[`~i`]*Zeta[i] is the term that relates the coordinates of two inertial systems of reference that move with respect to each other at constant velocity v.  In this section, K[`~i`]*Zeta[i] is rewritten in terms of that velocity, arriving at equation (11.98)  of Jackson's book [1]. The key observation is that the 3D vector Zeta[i], can be rewritten in terms of arctanh(beta), where beta = v/c and c is the velocity of light (for the rationale of that relation, see [2], sec 4, discussion before formula (4.3)).

 

Use a macro - say ub - to represent the atomic variable `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))` (this variable can be entered as `#mover(mi("β"),mo("ˆ")`. In general, to create atomic variables, see the section on Atomic Variables of the page 2DMathDetails ).

 

macro(ub = `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`)

ub[j] = [ub[1], ub[2], ub[3]], Zeta[j] = ub[j]*arctanh(beta)

`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[j] = [`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1], `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2], `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]], Zeta[j] = `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[j]*arctanh(beta)

(54)

Define(`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[j] = [`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1], `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2], `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]], Zeta[j] = `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[j]*arctanh(beta))

{Lambda, `𝕃`[mu, nu], Physics:-Dgamma[mu], K[i], Physics:-Psigma[mu], S[i], Zeta[i], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-gamma_[a, b], omega[i], Physics:-LeviCivita[alpha, beta, mu, nu], `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[j]}

(55)

With these two definitions, and excluding the rotation term S[`~i`]*omega[i] we have

%LM[`~μ`, nu] = Zeta[j]*K[j]

`%𝕃`[`~μ`, nu] = Zeta[j]*K[`~j`]

(56)

SumOverRepeatedIndices(`%𝕃`[`~μ`, nu] = Zeta[j]*K[`~j`])

`%𝕃`[`~μ`, nu] = arctanh(beta)*(K[`~1`]*`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]+K[`~2`]*`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]+K[`~3`]*`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3])

(57)

Library:-PerformMatrixOperations(`%𝕃`[`~μ`, nu] = arctanh(beta)*(K[`~1`]*`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]+K[`~2`]*`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]+K[`~3`]*`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]))

`%𝕃`[`~μ`, nu] = (array( 1 .. 4, 1 .. 4, [( 3, 1 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]*arctanh(beta)), ( 4, 2 ) = (0), ( 1, 2 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]*arctanh(beta)), ( 3, 2 ) = (0), ( 1, 3 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]*arctanh(beta)), ( 4, 3 ) = (0), ( 4, 4 ) = (0), ( 1, 1 ) = (0), ( 2, 1 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]*arctanh(beta)), ( 3, 3 ) = (0), ( 2, 4 ) = (0), ( 1, 4 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]*arctanh(beta)), ( 2, 2 ) = (0), ( 2, 3 ) = (0), ( 4, 1 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]*arctanh(beta)), ( 3, 4 ) = (0)  ] ))

(58)

 

From this expression, the form of "Lambda[nu]^(mu)" can be obtained as in (24) using LinearAlgebra:-MatrixExponential and simplifying the result taking into account that `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[j] is a unit vector

SumOverRepeatedIndices(ub[j]^2) = 1

`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]^2+`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]^2+`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]^2 = 1

(59)

exp(lhs(`%𝕃`[`~μ`, nu] = (array( 1 .. 4, 1 .. 4, [( 3, 3 ) = (0), ( 2, 3 ) = (0), ( 4, 2 ) = (0), ( 1, 1 ) = (0), ( 1, 2 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]*arctanh(beta)), ( 4, 4 ) = (0), ( 4, 1 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]*arctanh(beta)), ( 3, 1 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]*arctanh(beta)), ( 3, 4 ) = (0), ( 4, 3 ) = (0), ( 1, 4 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]*arctanh(beta)), ( 3, 2 ) = (0), ( 1, 3 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]*arctanh(beta)), ( 2, 4 ) = (0), ( 2, 1 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]*arctanh(beta)), ( 2, 2 ) = (0)  ] )))) = simplify(LinearAlgebra:-MatrixExponential(rhs(`%𝕃`[`~μ`, nu] = (array( 1 .. 4, 1 .. 4, [( 3, 3 ) = (0), ( 2, 3 ) = (0), ( 4, 2 ) = (0), ( 1, 1 ) = (0), ( 1, 2 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]*arctanh(beta)), ( 4, 4 ) = (0), ( 4, 1 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]*arctanh(beta)), ( 3, 1 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]*arctanh(beta)), ( 3, 4 ) = (0), ( 4, 3 ) = (0), ( 1, 4 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]*arctanh(beta)), ( 3, 2 ) = (0), ( 1, 3 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]*arctanh(beta)), ( 2, 4 ) = (0), ( 2, 1 ) = (`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]*arctanh(beta)), ( 2, 2 ) = (0)  ] )))), {`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]^2+`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]^2+`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]^2 = 1})

exp(`%𝕃`[`~μ`, nu]) = Matrix(%id = 36893488153234621252)

(60)

It is useful at this point to analyze the dependency on the components of `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[j] of this matrix

"map(u -> indets(u,specindex(ub)), rhs(?))"

Matrix(%id = 36893488151918822812)

(61)

We see that the diagonal element [4, 4] depends on two instead of only one component of  `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[j]. That is due to the simplification with respect to side relations , performed in (60), that constructs an elimination Groebner Basis that cannot reduce at once, using the single equation (59), the dependency of all of the elements [2, 2], [3, 3] and [4, 4] to a single component of  `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[j]. So, to reduce further the dependency of the [4, 4] element, this component of (60) requires one more simplification step, using a different elimination strategy, explicitly requesting the elimination of "{(beta)[1],(beta)[2]}"

"rhs(?)[4,4]"

((`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]^2+`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]^2)*(-beta^2+1)^(1/2)-`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]^2-`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]^2+1)/(-beta^2+1)^(1/2)

(62)

 

simplify(((`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]^2+`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]^2)*(-beta^2+1)^(1/2)-`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]^2-`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]^2+1)/(-beta^2+1)^(1/2), {`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]^2+`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]^2+`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]^2 = 1}, {`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1], `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]})

(-(-beta^2+1)^(1/2)*`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]^2+`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]^2+(-beta^2+1)^(1/2))/(-beta^2+1)^(1/2)

(63)

This result involves only `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3], and with it the form of Lambda[`~mu`, nu] = exp(`%𝕃`[`~mu`, nu]) becomes

"subs(1/(-beta^2+1)^(1/2)*((`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]^2+`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]^2)*(-beta^2+1)^(1/2)-`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1]^2-`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2]^2+1) = (-(-beta^2+1)^(1/2)*`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]^2+`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3]^2+(-beta^2+1)^(1/2))/(-beta^2+1)^(1/2),?)"

exp(`%𝕃`[`~μ`, nu]) = Matrix(%id = 36893488151918876660)

(64)

Replacing now the components of the unit vector `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[j] by the components of the vector `#mover(mi("β",fontstyle = "normal"),mo("→"))` divided by its modulus beta

seq(ub[j] = beta[j]/beta, j = 1 .. 3)

`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1] = beta[1]/beta, `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[2] = beta[2]/beta, `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[3] = beta[3]/beta

(65)

and recalling that

exp(`%𝕃`[`~μ`, nu]) = Lambda[`~μ`, nu]

exp(`%𝕃`[`~μ`, nu]) = Lambda[`~μ`, nu]

(66)

to get equation (11.98) in Jackson's book it suffices to introduce (the customary notation)

1/sqrt(-beta^2+1) = gamma

1/(-beta^2+1)^(1/2) = gamma

(67)

"simplify(subs(`#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[1] = beta[1]/beta, exp(`%𝕃`[`~μ`,nu]) = Lambda[`~μ`,nu], 1/(-beta^2+1)^(1/2) = gamma,(1/(-beta^2+1)^(1/2) = gamma)^(-1),?))"

Lambda[`~μ`, nu] = Matrix(%id = 36893488151911556148)

(68)

 

This is equation (11.98) in Jackson's book.

 

Finally, to get the form of this general Lorentz transformation excluding 3D rotations, directly expressed in terms of the relative velocity v of the two inertial systems of references, introduce

v[i] = [v__x, v__y, v__z], beta[i] = v[i]/c

v[i] = [v__x, v__y, v__z], beta[i] = v[i]/c

(69)

At this point it suffices to Define (69) as tensors

Define(v[i] = [v__x, v__y, v__z], beta[i] = v[i]/c)

{Lambda, `𝕃`[mu, nu], Physics:-Dgamma[mu], K[i], Physics:-Psigma[mu], S[i], Zeta[i], beta[i], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-gamma_[a, b], omega[i], v[i], Physics:-LeviCivita[alpha, beta, mu, nu], `#mover(mi("β",fontstyle = "normal"),mo("ˆ"))`[j]}

(70)

and remove beta and gamma from the formulation using

(rhs = lhs)(1/(-beta^2+1)^(1/2) = gamma), beta = v/c

gamma = 1/(-beta^2+1)^(1/2), beta = v/c

(71)

"simplify(subs(gamma = 1/(-beta^2+1)^(1/2),simplify(?)),size) "

Lambda[`~μ`, nu] = Matrix(%id = 36893488153289646316)

(72)

NULL

``

NULL

References

 

[1] J.D. Jackson, "Classical Electrodynamics", third edition, 1999.

[2] L.D. Landau, E.M. Lifshitz, "The Classical Theory of Fields", Course of Theoretical Physics V.2, 4th revised English edition, 1975.

NULL

Download Deriving_the_mathematical_form_of_Lorentz_transformations.mw

Deriving_the_mathematical_form_of_Lorentz_transformations.pdf

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

This is an interesting exercise, the computation of the Liénard–Wiechert potentials describing the classical electromagnetic field of a moving electric point charge, a problem of a 3rd year undergrad course in Electrodynamics. The calculation is nontrivial and is performed below using the Physics  package, following the presentation in [1] (Landau & Lifshitz "The classical theory of fields"). I have not seen this calculation performed on a computer algebra worksheet before. Thus, this also showcases the more advanced level of symbolic problems that can currently be tackled on a Maple worksheet. At the end, the corresponding document is linked  and with it the computation below can be reproduced. There is also a link to a corresponding PDF file with all the sections open.

Moving charges:
The retarded and Liénard-Wiechert potentials, and the fields `#mover(mi("E"),mo("→"))` and `#mover(mi("H"),mo("→"))`

Freddy Baudine(1), Edgardo S. Cheb-Terrab(2)

(1) Retired, passionate about Mathematics and Physics

(2) Physics, Differential Equations and Mathematical Functions, Maplesoft

 

Generally speaking, determining the electric and magnetic fields of a distribution of charges involves determining the potentials `ϕ` and `#mover(mi("A"),mo("→"))`, followed by determining the fields `#mover(mi("E"),mo("→"))` and `#mover(mi("H"),mo("→"))` from

`#mover(mi("E"),mo("→"))` = -(diff(`#mover(mi("A"),mo("→"))`, t))/c-%Gradient(`ϕ`(X)),        `#mover(mi("H"),mo("→"))` = `&x`(VectorCalculus[Nabla], `#mover(mi("A"),mo("→"))`)

In turn, the formulation of the equations for `ϕ` and `#mover(mi("A"),mo("→"))` is simple: they follow from the 4D second pair of Maxwell equations, in tensor notation

"`∂`[k](F[]^( i, k))=-(4 Pi)/c j^( i)"

where "F[]^( i, k)" is the electromagnetic field tensor and j^i is the 4D current. After imposing the Lorentz condition

`∂`[i](A^i) = 0,     i.e.    (diff(`ϕ`, t))/c+VectorCalculus[Nabla].`#mover(mi("A"),mo("→"))` = 0

we get

`∂`[k](`∂`[`~k`](A^i)) = 4*Pi*j^i/c

which in 3D form results in

"(∇)^2A-1/(c^2) (((∂)^2)/(∂t^2)( A))=-(4 Pi)/c j"

 

Laplacian(`ϕ`)-(diff(`ϕ`, t, t))/c^2 = -4*Pi*rho/c

where `#mover(mi("j"),mo("→"))` is the current and rho is the charge density.

 

Following the presentation shown in [1] (Landau and Lifshitz, "The classical theory of fields", sec. 62 and 63), below we solve these equations for `ϕ` and `#mover(mi("A"),mo("→"))` resulting in the so-called retarded potentials, then recompute these fields as produced by a charge moving along a given trajectory `#mover(mi("r"),mo("→"))` = r__0(t) - the so-called Liénard-Wiechert potentials - finally computing an explicit form for the corresponding `#mover(mi("E"),mo("→"))` and `#mover(mi("H"),mo("→"))`.

 

While the computation of the generic retarded potentials is, in principle, simple, obtaining their form for a charge moving along a given trajectory `#mover(mi("r"),mo("→"))` = r__0(t), and from there the form of the fields `#mover(mi("E"),mo("→"))` and `#mover(mi("H"),mo("→"))` shown in Landau's book, involves nontrivial algebraic manipulations. The presentation below thus also shows a technique to map onto the computer the manipulations typically done with paper and pencil for these problems. To reproduce the contents below, the Maplesoft Physics Updates v.1252 or newer is required.

NULL

with(Physics); Setup(coordinates = Cartesian); with(Vectors)

[coordinatesystems = {X}]

(1)

The retarded potentials phi and `#mover(mi("A"),mo("→"))`

 

 

The equations which determine the scalar and vector potentials of an arbitrary electromagnetic field are input as

CompactDisplay((`ϕ`, rho, A_, j_)(X))

j_(x, y, z, t)*`will now be displayed as`*j_

(2)

%Laplacian(`ϕ`(X))-(diff(`ϕ`(X), t, t))/c^2 = -4*Pi*rho(X)

%Laplacian(varphi(X))-(diff(diff(varphi(X), t), t))/c^2 = -4*Pi*rho(X)

(3)

%Laplacian(A_(X))-(diff(A_(X), t, t))/c^2 = -4*Pi*j_(X)

%Laplacian(A_(X))-(diff(diff(A_(X), t), t))/c^2 = -4*Pi*j_(X)

(4)

The solutions to these inhomogeneous equations are computed as the sum of the solutions for the equations without right-hand side plus a particular solution to the equation with right-hand side.

Computing the solution to the equations for `ϕ`(X) and  `#mover(mi("A"),mo("→"))`(X)

   

The Liénard-Wiechert potentials of a charge moving along `#mover(mi("r"),mo("→"))` = r__0_(t)

 

From (13), the potential at the point X = (x, y, z, t)is determined by the charge e(t-r/c), i.e. by the position of the charge e at the earlier time

`#msup(mi("t"),mo("'",fontweight = "bold"))` = t-LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)/c

The quantityLinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)is the 3D distance from the position of the charge at the time diff(t(x), x) to the 3D point of observationx, y, z. In the previous section, the charge was located at the origin and at rest, so LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`) = r, the radial coordinate. If the charge is moving, say on a path r__0_(t), we have

`#mover(mi("R"),mo("→"))` = `#mover(mi("r"),mo("→"))`-r__0_(`#msup(mi("t"),mo("'",fontweight = "bold"))`)

From (13)`ϕ`(r, t) = de(t-r/c)/r and the definition of `#msup(mi("t"),mo("'",fontweight = "bold"))` above, the potential `ϕ`(r, t) of a moving charge can be written as

`ϕ`(r, t(x)) = e/LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`) and e/LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`) = e/(c*(t(x)-(diff(t(x), x))))

When the charge is at rest, in the Lorentz gauge we are working, the vector potential is `#mover(mi("A"),mo("→"))` = 0. When the charge is moving, the form of `#mover(mi("A"),mo("→"))` can be found searching for a solution to "(∇)^2A-1/(c^2) (((∂)^2)/(∂t^2)( A))=-(4 Pi)/c j" that gives `#mover(mi("A"),mo("→"))` = 0 when `#mover(mi("v"),mo("→"))` = 0. Following [1], this solution can be written as

"A( )^(alpha)=(e u( )^(alpha))/(`R__beta` u^(beta))" 

where u^mu is the four velocity of the charge, "R^(mu)  =  r^( mu)-`r__0`^(mu)  =  [(r)-(`r__`),c(t-t')]".  

 

Without showing the intermediate steps, [1] presents the three dimensional vectorial form of these potentials `ϕ` and `#mover(mi("A"),mo("→"))` as

 

`ϕ` = e/(R-`#mover(mi("v"),mo("→"))`/c.`#mover(mi("R"),mo("→"))`),   `#mover(mi("A"),mo("→"))` = e*`#mover(mi("v"),mo("→"))`/(c*(R-`#mover(mi("v"),mo("→"))`/c.`#mover(mi("R"),mo("→"))`))

Computing the vectorial form of the Liénard-Wiechert potentials

   

The electric and magnetic fields `#mover(mi("E"),mo("→"))` and `#mover(mi("H"),mo("→"))` of a charge moving along `#mover(mi("r"),mo("→"))` = r__0_(t)

 

The electric and magnetic fields at a point x, y, z, t are calculated from the potentials `ϕ` and `#mover(mi("A"),mo("→"))` through the formulas

 

`#mover(mi("E"),mo("→"))`(x, y, z, t) = -(diff(`#mover(mi("A"),mo("→"))`(x, y, z, t), t))/c-(%Gradient(`ϕ`(X)))(x, y, z, t),        `#mover(mi("H"),mo("→"))`(x, y, z, t) = `&x`(VectorCalculus[Nabla], `#mover(mi("A"),mo("→"))`(x, y, z, t))

where, for the case of a charge moving on a path r__0_(t), these potentials were calculated in the previous section as (24) and (18)

`ϕ`(x, y, z, t) = e/(LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)-`#mover(mi("R"),mo("→"))`.(`#mover(mi("v"),mo("→"))`/c))

`#mover(mi("A"),mo("→"))`(x, y, z, t) = e*`#mover(mi("v"),mo("→"))`/(c*(LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)-`#mover(mi("R"),mo("→"))`.(`#mover(mi("v"),mo("→"))`/c)))

These two expressions, however, depend on the time only through the retarded time t__0. This dependence is within `#mover(mi("R"),mo("→"))` = `#mover(mi("r"),mo("→"))`(x, y, z)-r__0_(t__0(x, y, z, t)) and through the velocity of the charge `#mover(mi("v"),mo("→"))`(t__0(x, y, z, t)). So, before performing the differentiations, this dependence on t__0(x, y, z, t) must be taken into account.

CompactDisplay(r_(x, y, z), (E_, H_, t__0)(x, y, z, t))

t__0(x, y, z, t)*`will now be displayed as`*t__0

(29)

R_ = r_(x, y, z)-r__0_(t__0(x, y, z, t)), v_ = v_(t__0(x, y, z, t))

R_ = r_(x, y, z)-r__0_(t__0(X)), v_ = v_(t__0(X))

(30)

The Electric field `#mover(mi("E"),mo("→"))` = -(diff(`#mover(mi("A"),mo("→"))`, t))/c-%Gradient(`ϕ`)

 

Computation of Gradient(`ϕ`(X)) 

Computation of "(∂A)/(∂t)"

   

 Collecting the results of the two previous subsections, we have for the electric field

`#mover(mi("E"),mo("→"))`(X) = -(diff(`#mover(mi("A"),mo("→"))`(X), t))/c-%Gradient(`ϕ`(X))

E_(X) = -(diff(A_(X), t))/c-%Gradient(varphi(X))

(60)

subs(%Gradient(varphi(X)) = -c*e*(-Physics[Vectors][Norm](v_)^2*R_-Physics[Vectors][Norm](R_)*c*v_+R_*c^2+Physics[Vectors][`.`](R_, a_)*R_+Physics[Vectors][`.`](R_, v_)*v_)/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3, Physics[Vectors]:-diff(A_(X), t) = e*(Physics[Vectors][Norm](R_)^2*a_*c-v_*Physics[Vectors][Norm](v_)^2*Physics[Vectors][Norm](R_)-Physics[Vectors][Norm](R_)*Physics[Vectors][`.`](R_, v_)*a_+v_*Physics[Vectors][`.`](R_, a_)*Physics[Vectors][Norm](R_)+c*v_*Physics[Vectors][`.`](R_, v_))/((1-Physics[Vectors][`.`](R_, v_)/(Physics[Vectors][Norm](R_)*c))*(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2*Physics[Vectors][Norm](R_)), E_(X) = -(diff(A_(X), t))/c-%Gradient(varphi(X)))

E_(X) = -e*(Physics:-Vectors:-Norm(R_)^2*a_*c-v_*Physics:-Vectors:-Norm(v_)^2*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-`.`(R_, v_)*a_+v_*Physics:-Vectors:-`.`(R_, a_)*Physics:-Vectors:-Norm(R_)+c*v_*Physics:-Vectors:-`.`(R_, v_))/(c*(1-Physics:-Vectors:-`.`(R_, v_)/(Physics:-Vectors:-Norm(R_)*c))*(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2*Physics:-Vectors:-Norm(R_))+c*e*(-Physics:-Vectors:-Norm(v_)^2*R_-Physics:-Vectors:-Norm(R_)*c*v_+R_*c^2+Physics:-Vectors:-`.`(R_, a_)*R_+Physics:-Vectors:-`.`(R_, v_)*v_)/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3

(61)

The book, presents this result as equation (63.8):

`#mover(mi("E"),mo("→"))` = e*(1-v^2/c^2)*(`#mover(mi("R"),mo("→"))`-`#mover(mi("v"),mo("→"))`*R/c)/(R-(`#mover(mi("v"),mo("→"))`.`#mover(mi("R"),mo("→"))`)/c)^3+`&x`(e*`#mover(mi("R"),mo("→"))`/c(R-(`#mover(mi("v"),mo("→"))`.`#mover(mi("R"),mo("→"))`)/c)^6, `&x`(`#mover(mi("R"),mo("→"))`-`#mover(mi("v"),mo("→"))`*R/c, `#mover(mi("a"),mo("→"))`))

where `≡`(R, LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)) and `≡`(v, LinearAlgebra[Norm](`#mover(mi("v"),mo("→"))`)). To rewrite (61) as in the above, introduce the two triple vector products

`&x`(R_, `&x`(v_, a_)); expand(%) = %

v_*Physics:-Vectors:-`.`(R_, a_)-Physics:-Vectors:-`.`(R_, v_)*a_ = Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(v_, a_))

(62)

simplify(E_(X) = -e*(Physics[Vectors][Norm](R_)^2*a_*c-v_*Physics[Vectors][Norm](v_)^2*Physics[Vectors][Norm](R_)-Physics[Vectors][Norm](R_)*Physics[Vectors][`.`](R_, v_)*a_+v_*Physics[Vectors][`.`](R_, a_)*Physics[Vectors][Norm](R_)+c*v_*Physics[Vectors][`.`](R_, v_))/(c*(1-Physics[Vectors][`.`](R_, v_)/(Physics[Vectors][Norm](R_)*c))*(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2*Physics[Vectors][Norm](R_))+c*e*(-Physics[Vectors][Norm](v_)^2*R_-Physics[Vectors][Norm](R_)*c*v_+R_*c^2+Physics[Vectors][`.`](R_, a_)*R_+Physics[Vectors][`.`](R_, v_)*v_)/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3, {v_*Physics[Vectors][`.`](R_, a_)-Physics[Vectors][`.`](R_, v_)*a_ = Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))})

E_(X) = e*(-Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(v_, a_))+R_*c*Physics:-Vectors:-`.`(R_, a_)-Physics:-Vectors:-Norm(R_)^2*a_*c+(-c^2*v_+v_*Physics:-Vectors:-Norm(v_)^2)*Physics:-Vectors:-Norm(R_)+R_*c^3-R_*c*Physics:-Vectors:-Norm(v_)^2)/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3

(63)

`&x`(R_, `&x`(R_, a_)); expand(%) = %

Physics:-Vectors:-`.`(R_, a_)*R_-Physics:-Vectors:-Norm(R_)^2*a_ = Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(R_, a_))

(64)

simplify(E_(X) = e*(-Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))+R_*c*Physics[Vectors][`.`](R_, a_)-Physics[Vectors][Norm](R_)^2*a_*c+(-c^2*v_+v_*Physics[Vectors][Norm](v_)^2)*Physics[Vectors][Norm](R_)+R_*c^3-R_*c*Physics[Vectors][Norm](v_)^2)/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3, {Physics[Vectors][`.`](R_, a_)*R_-Physics[Vectors][Norm](R_)^2*a_ = Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_))})

E_(X) = (c*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(R_, a_))-Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(v_, a_))+(c-Physics:-Vectors:-Norm(v_))*(c+Physics:-Vectors:-Norm(v_))*(R_*c-Physics:-Vectors:-Norm(R_)*v_))*e/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3

(65)

Split now this result into two terms, one of them involving the acceleration `#mover(mi("a"),mo("→"))`. For that purpose first expand the expression without expanding the cross products

lhs(E_(X) = (c*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_))-Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))+(c-Physics[Vectors][Norm](v_))*(c+Physics[Vectors][Norm](v_))*(R_*c-Physics[Vectors][Norm](R_)*v_))*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3) = frontend(expand, [rhs(E_(X) = (c*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_))-Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))+(c-Physics[Vectors][Norm](v_))*(c+Physics[Vectors][Norm](v_))*(R_*c-Physics[Vectors][Norm](R_)*v_))*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3)])

E_(X) = e*Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-Norm(v_)^2*v_/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3-e*Physics:-Vectors:-Norm(R_)*c^2*v_/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3-e*Physics:-Vectors:-Norm(v_)^2*R_*c/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3+e*R_*c^3/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3+e*c*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(R_, a_))/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3-e*Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(v_, a_))/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3

(66)

Introduce the notation used in the textbook, `≡`(R, LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)) and `≡`(v, LinearAlgebra[Norm](`#mover(mi("v"),mo("→"))`)) and proceed with the splitting

lhs(E_(X) = (c*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_))-Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))+(c-Physics[Vectors][Norm](v_))*(c+Physics[Vectors][Norm](v_))*(R_*c-Physics[Vectors][Norm](R_)*v_))*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3) = subs(Norm(R_) = R, Norm(v_) = v, add(normal([selectremove(`not`(has), rhs(E_(X) = e*Physics[Vectors][Norm](R_)*Physics[Vectors][Norm](v_)^2*v_/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-e*Physics[Vectors][Norm](R_)*c^2*v_/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-e*Physics[Vectors][Norm](v_)^2*R_*c/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3+e*R_*c^3/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3+e*c*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_))/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-e*Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3), `#mover(mi("a"),mo("→"))`)])))

E_(X) = e*(-R*c^2*v_+R*v^2*v_+R_*c^3-R_*c*v^2)/(c*R-Physics:-Vectors:-`.`(R_, v_))^3-e*(R*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(v_, a_))-c*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(R_, a_)))/(c*R-Physics:-Vectors:-`.`(R_, v_))^3

(67)

Rearrange only the first term using simplify; that can be done in different ways, perhaps the simplest is using subsop

subsop([2, 1] = simplify(op([2, 1], E_(X) = e*(-R*c^2*v_+R*v^2*v_+R_*c^3-R_*c*v^2)/(c*R-Physics[Vectors][`.`](R_, v_))^3-e*(R*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))-c*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_)))/(c*R-Physics[Vectors][`.`](R_, v_))^3)), E_(X) = e*(-R*c^2*v_+R*v^2*v_+R_*c^3-R_*c*v^2)/(c*R-Physics[Vectors][`.`](R_, v_))^3-e*(R*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](v_, a_))-c*Physics[Vectors][`&x`](R_, Physics[Vectors][`&x`](R_, a_)))/(c*R-Physics[Vectors][`.`](R_, v_))^3)

E_(X) = e*(c-v)*(c+v)*(-R*v_+R_*c)/(c*R-Physics:-Vectors:-`.`(R_, v_))^3-e*(R*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(v_, a_))-c*Physics:-Vectors:-`&x`(R_, Physics:-Vectors:-`&x`(R_, a_)))/(c*R-Physics:-Vectors:-`.`(R_, v_))^3

(68)

NULL

By eye this result is mathematically equal to equation (63.8) of the textbook, shown here above before (62) .

 

Algebraic manipulation rewriting (68) as the textbook equation (63.8)

   

The magnetic field  `#mover(mi("H"),mo("→"))` = `&x`(VectorCalculus[Nabla], `#mover(mi("A"),mo("→"))`)

 

 

The book does not show an explicit form for `#mover(mi("H"),mo("→"))`, it only indicates that it is related to the electric field by the formula

 

`#mover(mi("H"),mo("→"))` = `&x`(`#mover(mi("R"),mo("→"))`, `#mover(mi("E"),mo("→"))`)/LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)

 

Thus in this section we compute the explicit form of `#mover(mi("H"),mo("→"))` and show that this relationship mentioned in the book holds. To compute `#mover(mi("H"),mo("→"))` = `&x`(VectorCalculus[Nabla], `#mover(mi("A"),mo("→"))`) we proceed as done in the previous sections, the right-hand side should be taken at the previous (retarded) time t__0. For clarity, turn OFF the compact display of functions.

OFF

 

We need to calculate

H_(X) = Curl(A_(x, y, z, t__0(x, y, z, t)))

H_(X) = Physics:-Vectors:-Curl(A_(x, y, z, t__0(X)))

(75)

Deriving the chain rule `&x`(VectorCalculus[Nabla], `#mover(mi("A"),mo("→"))`(t__0(x, y, z, t))) = %Curl(A_(x, y, z, `#msub(mi("t"),mi("0"))`))+`&x`(%Gradient(`#msub(mi("t"),mi("0"))`(X)), diff(`#mover(mi("A"),mo("→"))`(t__0), t__0))

   

So applying to (75)  the chain rule derived in the previous subsection we have

H_(X) = %Curl(A_(x, y, z, t__0))+`&x`(%Gradient(t__0(X)), diff(A_(x, y, z, t__0), t__0))

H_(X) = %Curl(A_(x, y, z, t__0))+Physics:-Vectors:-`&x`(%Gradient(t__0(X)), diff(A_(x, y, z, t__0), t__0))

(87)

where t__0 is taken as a function of x, y, z, t only in %Gradient(`#msub(mi("t"),mi("0"))`(X)). Now that the functionality is understood, turning ON the compact display of functions and displaying the fields by their names,

CompactDisplay(H_(X) = %Curl(A_(x, y, z, t__0))+Physics[Vectors][`&x`](%Gradient(t__0(X)), diff(A_(x, y, z, t__0), t__0)), E_(X))

E_(x, y, z, t)*`will now be displayed as`*E_

(88)

The value of %Gradient(`#msub(mi("t"),mi("0"))`(X)) is computed lines above as (48)

%Gradient(t__0(X)) = R_/(-c*Physics[Vectors][Norm](R_)+Physics[Vectors][`.`](R_, v_))

%Gradient(t__0(X)) = R_/(-c*Physics:-Vectors:-Norm(R_)+Physics:-Vectors:-`.`(R_, v_))

(89)

The expression for `#mover(mi("A"),mo("→"))` with no dependency is computed lines above, as (28),

subs(A_ = A_(x, y, z, t__0), A_ = e*v_/((Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_/c))*c))

A_(x, y, z, t__0) = e*v_/((Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_)/c)*c)

(90)

The expressions for `#mover(mi("R"),mo("→"))` and the velocity in terms of t__0 with no dependency are

R_ = r_(x, y, z)-r__0_(t__0), v_ = v_(t__0)

R_ = r_(x, y, z)-r__0_(t__0), v_ = v_(t__0)

(91)

CompactDisplay(r_(x, y, z))

r_(x, y, z)*`will now be displayed as`*r_

(92)

subs(R_ = r_(x, y, z)-r__0_(t__0), v_ = v_(t__0), [%Gradient(t__0(X)) = R_/(-c*Physics[Vectors][Norm](R_)+Physics[Vectors][`.`](R_, v_)), A_(x, y, z, t__0) = e*v_/((Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_)/c)*c)])

[%Gradient(t__0(X)) = (r_(x, y, z)-r__0_(t__0))/(-c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), v_(t__0))), A_(x, y, z, t__0) = e*v_(t__0)/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), v_(t__0))/c)*c)]

(93)

Introducing this into "H(X)=`%Curl`(A_(x,y,z,t[`0`]))+(`%Gradient`(t[`0`](X)))*((∂A)/(∂`t__0`))",

eval(H_(X) = %Curl(A_(x, y, z, t__0))+Physics[Vectors][`&x`](%Gradient(t__0(X)), diff(A_(x, y, z, t__0), t__0)), [%Gradient(t__0(X)) = (r_(x, y, z)-r__0_(t__0))/(-c*Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))+Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), v_(t__0))), A_(x, y, z, t__0) = e*v_(t__0)/((Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))-Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), v_(t__0))/c)*c)])

H_(X) = %Curl(e*v_(t__0)/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), v_(t__0))/c)*c))+Physics:-Vectors:-`&x`(r_(x, y, z)-r__0_(t__0), -e*v_(t__0)*(-Physics:-Vectors:-`.`(diff(r__0_(t__0), t__0), r_(x, y, z)-r__0_(t__0))/Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))-(-Physics:-Vectors:-`.`(diff(r__0_(t__0), t__0), v_(t__0))+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), diff(v_(t__0), t__0)))/c)/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), v_(t__0))/c)^2*c)+e*(diff(v_(t__0), t__0))/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), v_(t__0))/c)*c))/(-c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_(t__0))+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_(t__0), v_(t__0)))

(94)

Before computing the first term `&x`(VectorCalculus[Nabla], () .. ()), for readability, re-introduce the velocity diff(`#msub(mi("r"),mi("0_"))`(t__0), t__0) = `#mover(mi("v"),mo("→"))`, the acceleration diff(`#mover(mi("v"),mo("→"))`(t__0), t__0) = `#mover(mi("a"),mo("→"))`, then remove the dependency of these functions on t__0, not relevant anymore since there are no more derivatives with respect to t__0. Performing these substitutions in sequence,

diff(`#msub(mi("r"),mi("0_"))`(t__0), t__0) = `#mover(mi("v"),mo("→"))`, diff(`#mover(mi("v"),mo("→"))`(t__0), t__0) = `#mover(mi("a"),mo("→"))`, `#mover(mi("v"),mo("→"))`(t__0) = `#mover(mi("v"),mo("→"))`, `#msub(mi("r"),mi("0_"))`(t__0) = `#msub(mi("r"),mi("0_"))`

diff(r__0_(t__0), t__0) = v_, diff(v_(t__0), t__0) = a_, v_(t__0) = v_, r__0_(t__0) = r__0_

(95)

subs(diff(r__0_(t__0), t__0) = v_, diff(v_(t__0), t__0) = a_, v_(t__0) = v_, r__0_(t__0) = r__0_, H_(X) = %Curl(e*v_(t__0)/((Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))-Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), v_(t__0))/c)*c))+Physics[Vectors][`&x`](r_(x, y, z)-r__0_(t__0), -e*v_(t__0)*(-Physics[Vectors][`.`](diff(r__0_(t__0), t__0), r_(x, y, z)-r__0_(t__0))/Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))-(-Physics[Vectors][`.`](diff(r__0_(t__0), t__0), v_(t__0))+Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), diff(v_(t__0), t__0)))/c)/((Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))-Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), v_(t__0))/c)^2*c)+e*(diff(v_(t__0), t__0))/((Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))-Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), v_(t__0))/c)*c))/(-c*Physics[Vectors][Norm](r_(x, y, z)-r__0_(t__0))+Physics[Vectors][`.`](r_(x, y, z)-r__0_(t__0), v_(t__0))))

H_(X) = %Curl(e*v_/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_)/c)*c))+Physics:-Vectors:-`&x`(r_(x, y, z)-r__0_, -e*v_*(-Physics:-Vectors:-`.`(v_, r_(x, y, z)-r__0_)/Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-(-Physics:-Vectors:-`.`(v_, v_)+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, a_))/c)/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_)/c)^2*c)+e*a_/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_)/c)*c))/(-c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))

(96)

Activate now the inert curl `&x`(VectorCalculus[Nabla], () .. ())

value(H_(X) = %Curl(e*v_/((Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)/c)*c))+Physics[Vectors][`&x`](r_(x, y, z)-r__0_, -e*v_*(-Physics[Vectors][`.`](v_, r_(x, y, z)-r__0_)/Physics[Vectors][Norm](r_(x, y, z)-r__0_)-(-Physics[Vectors][`.`](v_, v_)+Physics[Vectors][`.`](r_(x, y, z)-r__0_, a_))/c)/((Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)/c)^2*c)+e*a_/((Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)/c)*c))/(-c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)+Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)))

H_(X) = e*Physics:-Vectors:-`&x`(-c^2*_i*Physics:-Vectors:-`.`(diff(r_(x, y, z), x), r_(x, y, z)-r__0_)/((c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))^2*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_))+c*_i*Physics:-Vectors:-`.`(diff(r_(x, y, z), x), v_)/(c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))^2-c^2*_j*Physics:-Vectors:-`.`(diff(r_(x, y, z), y), r_(x, y, z)-r__0_)/((c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))^2*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_))+c*_j*Physics:-Vectors:-`.`(diff(r_(x, y, z), y), v_)/(c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))^2-c^2*_k*Physics:-Vectors:-`.`(diff(r_(x, y, z), z), r_(x, y, z)-r__0_)/((c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))^2*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_))+c*_k*Physics:-Vectors:-`.`(diff(r_(x, y, z), z), v_)/(c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))^2, v_)/c+Physics:-Vectors:-`&x`(r_(x, y, z)-r__0_, -e*v_*(-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_)/Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-(-Physics:-Vectors:-Norm(v_)^2+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, a_))/c)/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_)/c)^2*c)+e*a_/((Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)-Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_)/c)*c))/(-c*Physics:-Vectors:-Norm(r_(x, y, z)-r__0_)+Physics:-Vectors:-`.`(r_(x, y, z)-r__0_, v_))

(97)

From (34)diff(`#mover(mi("r"),mo("→"))`, x) = `#mover(mi("i"),mo("∧"))`, diff(`#mover(mi("r"),mo("→"))`, y) = `#mover(mi("j"),mo("∧"))`, diff(`#mover(mi("r"),mo("→"))`, z) = `#mover(mi("k"),mo("∧"))`, and reintroducing `#mover(mi("r"),mo("→"))`(x, y, z)-r__0_ = `#mover(mi("R"),mo("→"))`

subs(diff(r_(x, y, z), x) = _i, diff(r_(x, y, z), y) = _j, diff(r_(x, y, z), z) = _k, `#mover(mi("r"),mo("→"))`(x, y, z)-r__0_ = `#mover(mi("R"),mo("→"))`, H_(X) = e*Physics[Vectors][`&x`](-c^2*_i*Physics[Vectors][`.`](diff(r_(x, y, z), x), r_(x, y, z)-r__0_)/((c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_))^2*Physics[Vectors][Norm](r_(x, y, z)-r__0_))+c*_i*Physics[Vectors][`.`](diff(r_(x, y, z), x), v_)/(c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_))^2-c^2*_j*Physics[Vectors][`.`](diff(r_(x, y, z), y), r_(x, y, z)-r__0_)/((c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_))^2*Physics[Vectors][Norm](r_(x, y, z)-r__0_))+c*_j*Physics[Vectors][`.`](diff(r_(x, y, z), y), v_)/(c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_))^2-c^2*_k*Physics[Vectors][`.`](diff(r_(x, y, z), z), r_(x, y, z)-r__0_)/((c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_))^2*Physics[Vectors][Norm](r_(x, y, z)-r__0_))+c*_k*Physics[Vectors][`.`](diff(r_(x, y, z), z), v_)/(c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_))^2, v_)/c+Physics[Vectors][`&x`](r_(x, y, z)-r__0_, -e*v_*(-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)/Physics[Vectors][Norm](r_(x, y, z)-r__0_)-(-Physics[Vectors][Norm](v_)^2+Physics[Vectors][`.`](r_(x, y, z)-r__0_, a_))/c)/((Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)/c)^2*c)+e*a_/((Physics[Vectors][Norm](r_(x, y, z)-r__0_)-Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)/c)*c))/(-c*Physics[Vectors][Norm](r_(x, y, z)-r__0_)+Physics[Vectors][`.`](r_(x, y, z)-r__0_, v_)))

H_(X) = e*Physics:-Vectors:-`&x`(-c^2*_i*Physics:-Vectors:-`.`(_i, R_)/((c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2*Physics:-Vectors:-Norm(R_))+c*_i*Physics:-Vectors:-`.`(_i, v_)/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2-c^2*_j*Physics:-Vectors:-`.`(_j, R_)/((c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2*Physics:-Vectors:-Norm(R_))+c*_j*Physics:-Vectors:-`.`(_j, v_)/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2-c^2*_k*Physics:-Vectors:-`.`(_k, R_)/((c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2*Physics:-Vectors:-Norm(R_))+c*_k*Physics:-Vectors:-`.`(_k, v_)/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^2, v_)/c+Physics:-Vectors:-`&x`(R_, -e*v_*(-Physics:-Vectors:-`.`(R_, v_)/Physics:-Vectors:-Norm(R_)-(-Physics:-Vectors:-Norm(v_)^2+Physics:-Vectors:-`.`(R_, a_))/c)/((Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_)/c)^2*c)+e*a_/((Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_)/c)*c))/(-c*Physics:-Vectors:-Norm(R_)+Physics:-Vectors:-`.`(R_, v_))

(98)

Simplify(H_(X) = e*Physics[Vectors][`&x`](-c^2*_i*Physics[Vectors][`.`](_i, R_)/((c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2*Physics[Vectors][Norm](R_))+c*_i*Physics[Vectors][`.`](_i, v_)/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2-c^2*_j*Physics[Vectors][`.`](_j, R_)/((c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2*Physics[Vectors][Norm](R_))+c*_j*Physics[Vectors][`.`](_j, v_)/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2-c^2*_k*Physics[Vectors][`.`](_k, R_)/((c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2*Physics[Vectors][Norm](R_))+c*_k*Physics[Vectors][`.`](_k, v_)/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^2, v_)/c+Physics[Vectors][`&x`](R_, -e*v_*(-Physics[Vectors][`.`](R_, v_)/Physics[Vectors][Norm](R_)-(-Physics[Vectors][Norm](v_)^2+Physics[Vectors][`.`](R_, a_))/c)/((Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_)/c)^2*c)+e*a_/((Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_)/c)*c))/(-c*Physics[Vectors][Norm](R_)+Physics[Vectors][`.`](R_, v_)))

H_(X) = (-e*c*Physics:-Vectors:-`&x`(R_, v_)*(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))+e*(-c*Physics:-Vectors:-`.`(R_, v_)+(Physics:-Vectors:-Norm(v_)^2-Physics:-Vectors:-`.`(R_, a_))*Physics:-Vectors:-Norm(R_))*Physics:-Vectors:-`&x`(R_, v_)-e*(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))*Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-`&x`(R_, a_))/((c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3*Physics:-Vectors:-Norm(R_))

(99)

To conclude, rearrange this expression as done with the one for the electric field `#mover(mi("E"),mo("→"))` at (65), so first expand  (99) without expanding the cross products

lhs(H_(X) = (-e*c*Physics[Vectors][`&x`](R_, v_)*(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))+e*(-c*Physics[Vectors][`.`](R_, v_)+(Physics[Vectors][Norm](v_)^2-Physics[Vectors][`.`](R_, a_))*Physics[Vectors][Norm](R_))*Physics[Vectors][`&x`](R_, v_)-e*(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))*Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, a_))/((c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3*Physics[Vectors][Norm](R_))) = frontend(expand, [rhs(H_(X) = (-e*c*Physics[Vectors][`&x`](R_, v_)*(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))+e*(-c*Physics[Vectors][`.`](R_, v_)+(Physics[Vectors][Norm](v_)^2-Physics[Vectors][`.`](R_, a_))*Physics[Vectors][Norm](R_))*Physics[Vectors][`&x`](R_, v_)-e*(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))*Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, a_))/((c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3*Physics[Vectors][Norm](R_)))])

H_(X) = -Physics:-Vectors:-Norm(R_)*Physics:-Vectors:-`&x`(R_, a_)*c*e/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3+Physics:-Vectors:-`&x`(R_, v_)*Physics:-Vectors:-Norm(v_)^2*e/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3-Physics:-Vectors:-`&x`(R_, v_)*c^2*e/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3+Physics:-Vectors:-`.`(R_, v_)*Physics:-Vectors:-`&x`(R_, a_)*e/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3-Physics:-Vectors:-`&x`(R_, v_)*Physics:-Vectors:-`.`(R_, a_)*e/(c*Physics:-Vectors:-Norm(R_)-Physics:-Vectors:-`.`(R_, v_))^3

(100)

Then introduce the notation used in the textbook, `≡`(R, LinearAlgebra[Norm](`#mover(mi("R"),mo("→"))`)) and `≡`(v, LinearAlgebra[Norm](`#mover(mi("v"),mo("→"))`)) and split into two terms, one of which contains the acceleration `#mover(mi("a"),mo("→"))`

lhs(H_(X) = -Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, a_)*c*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3+Physics[Vectors][`&x`](R_, v_)*Physics[Vectors][Norm](v_)^2*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-Physics[Vectors][`&x`](R_, v_)*c^2*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3+Physics[Vectors][`.`](R_, v_)*Physics[Vectors][`&x`](R_, a_)*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-Physics[Vectors][`&x`](R_, v_)*Physics[Vectors][`.`](R_, a_)*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3) = subs(Norm(R_) = R, Norm(v_) = v, add(normal([selectremove(`not`(has), rhs(H_(X) = -Physics[Vectors][Norm](R_)*Physics[Vectors][`&x`](R_, a_)*c*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3+Physics[Vectors][`&x`](R_, v_)*Physics[Vectors][Norm](v_)^2*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-Physics[Vectors][`&x`](R_, v_)*c^2*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3+Physics[Vectors][`.`](R_, v_)*Physics[Vectors][`&x`](R_, a_)*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3-Physics[Vectors][`&x`](R_, v_)*Physics[Vectors][`.`](R_, a_)*e/(c*Physics[Vectors][Norm](R_)-Physics[Vectors][`.`](R_, v_))^3), `#mover(mi("a"),mo("→"))`)])))

H_(X) = Physics:-Vectors:-`&x`(R_, v_)*e*(-c^2+v^2)/(c*R-Physics:-Vectors:-`.`(R_, v_))^3-e*(Physics:-Vectors:-`&x`(R_, a_)*R*c-Physics:-Vectors:-`&x`(R_, a_)*Physics:-Vectors:-`.`(R_, v_)+Physics:-Vectors:-`.`(R_, a_)*Physics:-Vectors:-`&x`(R_, v_))/(c*R-Physics:-Vectors:-`.`(R_, v_))^3

(101)

Verifying `#mover(mi("H"),mo("→"))` = `&x`(`#mover(mi("R"),mo("→"))`, `#mover(mi("E"),mo("→"))`)/R

   

References

 

NULL

[1] Landau, L.D., and Lifshitz, E.M. Course of Theoretical Physics Vol 2, The Classical Theory of Fields. Elsevier, 1975.

NULL

 

Download document: The_field_of_moving_charges.mw

Download PDF with sections open: The_field_of_moving_charges.pdf

 

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

       The Standard Model of Particle Physics in Maple 2022

 

One of the most important mathematical formulations in human history is that of the Standard Model in particle physics. It describes all the elementary particles (leptons like the electron, quarks, bosons as the Higgs or the photon), which in different arrangements, form all the observable particles in nature. The formulation is not just a tremendous theoretical achievement that rendered Nobel prizes but also a practical one. Basically, all the measurements performed in the particle accelerators at CERN and the Fermilab take this mathematical, abstract formulation as the starting point. However, for computer algebra systems, the complexity of the model is somewhat extreme: is not only the number of terms in the corresponding Lagrangian impressively large but also the mathematical properties of each of these objects that represented a challenge for a long time. With hacks of different kinds, the computer algebra representation of only some aspects of the Standard Model was possible, with restricted computational capabilities.

Hidden among the novelties of Maple 2022, a breakthrough in computer algebra is the introduction of a new, fully computable representation of the Standard Model. This representation includes the accessory commands to calculate related scattering amplitudes  (the essence of the computations behind particle collision experiments) and related Feynman integrals . This is a remarkable achievement in computational physics. And from the educational point of view, it brings one more brick of knowledge from "the dark side" of the moon into "the bright side." Making the Standard Model computations be at the tip of one's fingers completely transforms the possible experience we can have with the underlying knowledge.
 

The illustration below of this new Maple 2022 StandardModel package is advanced in time with regards to the release of Maple 2022 days ago, and introduces a new command, Lagrangian, that increases one level the usability of the package. The so updated StandardModel is distributed as usual, within the Maplesoft Physics Updates for Maple 2022.
 

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

 

Download: StandardModel.mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

Wirtinger Derivatives in Maple 2021

Generally speaking, there are two contexts for differentiating complex functions with respect to complex variables. In the first context, called the classical complex analysis, the derivatives of the complex components ( abs , argument , conjugate , Im , Re , signum ) with respect to complex variables do not exist (do not satisfy the Cauchy-Riemann conditions), with the exception of when they are holomorphic functions. All computer algebra systems implement the complex components in this context, and computationally represent all of abs(z), argument(z), conjugate(z), Im(z), Re(z), signum(z) as functions of z . Then, viewed as functions of z, none of them are analytic, so differentiability becomes an issue.

 

In the second context, first introduced by Poincare (also called Wirtinger calculus), in brief z and its conjugate conjugate(z) are taken as independent variables, and all the six derivatives of the complex components become computable, also with respect to conjugate(z). Technically speaking, Wirtinger calculus permits extending complex differentiation to non-holomorphic functions provided that they are ℝ-differentiable (i.e. differentiable functions of real and imaginary parts, taking f(z) = f(x, y) as a mapping "`ℝ`^(2)->`ℝ`^()").

 

In simpler terms, this subject is relevant because, in mathematical-physics formulations using paper and pencil, we frequently use Wirtinger calculus automatically. We take z and its conjugate conjugate(z) as independent variables, with that d*conjugate(z)*(1/(d*z)) = 0, d*z*(1/(d*conjugate(z))) = 0, and we compute with the operators "(∂)/(∂ z)", "(∂)/(∂ (z))" as partial differential operators that behave as ordinary derivatives. With that, all of abs(z), argument(z), conjugate(z), Im(z), Re(z), signum(z), become differentiable, since they are all expressible as functions of z and conjugate(z).

 

 

Wirtinger derivatives were implemented in Maple 18 , years ago, in the context of the Physics package. There is a setting, Physics:-Setup(wirtingerderivatives), that when set to true - an that is the default value when Physics is loaded - redefines the differentiation rules turning on Wirtinger calculus. The implementation, however, was incomplete, and the subject escaped through the cracks till recently mentioned in this Mapleprimes post.

 

Long intro. This post is to present the completion of Wirtinger calculus in Maple, distributed for everybody using Maple 2021 within the Maplesoft Physics Updates v.929 or newer. Load Physics and set the imaginary unit to be represented by I

 

with(Physics); interface(imaginaryunit = I)

 

The complex components are represented by the computer algebra functions

(FunctionAdvisor(complex_components))(z)

[Im(z), Re(z), abs(z), argument(z), conjugate(z), signum(z)]

(1)

They can all be expressed in terms of z and conjugate(z)

map(proc (u) options operator, arrow; u = convert(u, conjugate) end proc, [Im(z), Re(z), abs(z), argument(z), conjugate(z), signum(z)])

[Im(z) = ((1/2)*I)*(-z+conjugate(z)), Re(z) = (1/2)*z+(1/2)*conjugate(z), abs(z) = (z*conjugate(z))^(1/2), argument(z) = -I*ln(z/(z*conjugate(z))^(1/2)), conjugate(z) = conjugate(z), signum(z) = z/(z*conjugate(z))^(1/2)]

(2)

The main differentiation rules in the context of Wirtinger derivatives, that is, taking z and conjugate(z) as independent variables, are

map(%diff = diff, [Im(z), Re(z), abs(z), argument(z), conjugate(z), signum(z)], z)

[%diff(Im(z), z) = -(1/2)*I, %diff(Re(z), z) = 1/2, %diff(abs(z), z) = (1/2)*conjugate(z)/abs(z), %diff(argument(z), z) = -((1/2)*I)/z, %diff(conjugate(z), z) = 0, %diff(signum(z), z) = (1/2)/abs(z)]

(3)

Since in this context conjugate(z) is taken as - say - a mathematically-atomic variable (the computational representation is still the function conjugate(z)) we can differentiate all the complex components also with respect to  conjugate(z)

map(%diff = diff, [Im(z), Re(z), abs(z), argument(z), conjugate(z), signum(z)], conjugate(z))

[%diff(Im(z), conjugate(z)) = (1/2)*I, %diff(Re(z), conjugate(z)) = 1/2, %diff(abs(z), conjugate(z)) = (1/2)*z/abs(z), %diff(argument(z), conjugate(z)) = ((1/2)*I)*z/abs(z)^2, %diff(conjugate(z), conjugate(z)) = 1, %diff(signum(z), conjugate(z)) = -(1/2)*z^2/abs(z)^3]

(4)

For example, consider the following algebraic expression, starting with conjugate

eq__1 := conjugate(z)+z*conjugate(z)^2

conjugate(z)+z*conjugate(z)^2

(5)

Differentiating this expression with respect to z and conjugate(z) taking them as independent variables, is new, and in this example trivial

(%diff = diff)(eq__1, z)

%diff(conjugate(z)+z*conjugate(z)^2, z) = conjugate(z)^2

(6)

(%diff = diff)(eq__1, conjugate(z))

%diff(conjugate(z)+z*conjugate(z)^2, conjugate(z)) = 1+2*z*conjugate(z)

(7)

Switch to something less trivial, replace conjugate by the real part ReNULL

eq__2 := eval(eq__1, conjugate = Re)

Re(z)+z*Re(z)^2

(8)

To verify results further below, also express eq__2 in terms of conjugate

eq__22 := simplify(convert(eq__2, conjugate), size)

(1/4)*(z^2+z*conjugate(z)+2)*(z+conjugate(z))

(9)

New: differentiate eq__2 with respect to z and  conjugate(z)

(%diff = diff)(eq__2, z)

%diff(Re(z)+z*Re(z)^2, z) = 1/2+Re(z)^2+z*Re(z)

(10)

(%diff = diff)(eq__2, conjugate(z))

%diff(Re(z)+z*Re(z)^2, conjugate(z)) = 1/2+z*Re(z)

(11)

Note these results (10) and (11) are expressed in terms of Re(z), not conjugate(z). Let's compare with the derivative of eq__22 where everything is expressed in terms of z and conjugate(z). Take for instance the derivative with respect to z

(%diff = diff)(eq__22, z)

%diff((1/4)*(z^2+z*conjugate(z)+2)*(z+conjugate(z)), z) = (1/4)*(2*z+conjugate(z))*(z+conjugate(z))+(1/4)*z^2+(1/4)*z*conjugate(z)+1/2

(12)

To verify this result is mathematically equal to (10) expressed in terms of Re(z) take the difference of the right-hand sides

rhs((%diff(Re(z)+z*Re(z)^2, z) = 1/2+Re(z)^2+z*Re(z))-(%diff((1/4)*(z^2+z*conjugate(z)+2)*(z+conjugate(z)), z) = (1/4)*(2*z+conjugate(z))*(z+conjugate(z))+(1/4)*z^2+(1/4)*z*conjugate(z)+1/2)) = 0

Re(z)^2+z*Re(z)-(1/4)*(2*z+conjugate(z))*(z+conjugate(z))-(1/4)*z^2-(1/4)*z*conjugate(z) = 0

(13)

One quick way to verify the value of expressions like this one is to replace z = a+I*b and simplify "assuming" a andNULLb are realNULL

`assuming`([eval(Re(z)^2+z*Re(z)-(1/4)*(2*z+conjugate(z))*(z+conjugate(z))-(1/4)*z^2-(1/4)*z*conjugate(z) = 0, z = a+I*b)], [a::real, b::real])

a^2+(a+I*b)*a-(1/2)*(3*a+I*b)*a-(1/4)*(a+I*b)^2-(1/4)*(a+I*b)*(a-I*b) = 0

(14)

normal(a^2+(a+I*b)*a-(1/2)*(3*a+I*b)*a-(1/4)*(a+I*b)^2-(1/4)*(a+I*b)*(a-I*b) = 0)

0 = 0

(15)

The equivalent differentiation, this time replacing in eq__1 conjugate by abs; construct also the equivalent expression in terms of z and  conjugate(z) for verifying results

eq__3 := eval(eq__1, conjugate = abs)

abs(z)+abs(z)^2*z

(16)

eq__33 := simplify(convert(eq__3, conjugate), size)

(z*conjugate(z))^(1/2)+conjugate(z)*z^2

(17)

Since these two expressions are mathematically equal, their derivatives should be too, and the derivatives of eq__33 can be verified by eye since z and  conjugate(z) are taken as independent variables

(%diff = diff)(eq__3, z)

%diff(abs(z)+abs(z)^2*z, z) = (1/2)*conjugate(z)/abs(z)+z*conjugate(z)+abs(z)^2

(18)

(%diff = diff)(eq__33, z)

%diff((z*conjugate(z))^(1/2)+conjugate(z)*z^2, z) = (1/2)*conjugate(z)/(z*conjugate(z))^(1/2)+2*z*conjugate(z)

(19)

Eq (18) is expressed in terms of abs(z) = abs(z) while (19) is in terms of conjugate(z) = conjugate(z). Comparing as done in (14)

rhs((%diff(abs(z)+abs(z)^2*z, z) = (1/2)*conjugate(z)/abs(z)+z*conjugate(z)+abs(z)^2)-(%diff((z*conjugate(z))^(1/2)+conjugate(z)*z^2, z) = (1/2)*conjugate(z)/(z*conjugate(z))^(1/2)+2*z*conjugate(z))) = 0

(1/2)*conjugate(z)/abs(z)-z*conjugate(z)+abs(z)^2-(1/2)*conjugate(z)/(z*conjugate(z))^(1/2) = 0

(20)

`assuming`([eval((1/2)*conjugate(z)/abs(z)-z*conjugate(z)+abs(z)^2-(1/2)*conjugate(z)/(z*conjugate(z))^(1/2) = 0, z = a+I*b)], [a::real, b::real])

(1/2)*(a-I*b)/(a^2+b^2)^(1/2)-(a+I*b)*(a-I*b)+a^2+b^2-(1/2)*(a-I*b)/((a+I*b)*(a-I*b))^(1/2) = 0

(21)

simplify((1/2)*(a-I*b)/(a^2+b^2)^(1/2)-(a+I*b)*(a-I*b)+a^2+b^2-(1/2)*(a-I*b)/((a+I*b)*(a-I*b))^(1/2) = 0)

0 = 0

(22)

To mention but one not so famliar case, consider the derivative of the sign of a complex number, represented in Maple by signum(z). So our testing expression is

eq__4 := eval(eq__1, conjugate = signum)

signum(z)+z*signum(z)^2

(23)

This expression can also be rewritten in terms of z and  conjugate(z) 

eq__44 := simplify(convert(eq__4, conjugate), size)

z/(z*conjugate(z))^(1/2)+z^2/conjugate(z)

(24)

This time differentiate with respect to conjugate(z),

(%diff = diff)(eq__4, conjugate(z))

%diff(signum(z)+z*signum(z)^2, conjugate(z)) = -(1/2)*z^2/abs(z)^3-z^3*signum(z)/abs(z)^3

(25)

Here again, the differentiation of eq__44, that is expressed entirely in terms of z and  conjugate(z), can be computed by eye

(%diff = diff)(eq__44, conjugate(z))

%diff(z/(z*conjugate(z))^(1/2)+z^2/conjugate(z), conjugate(z)) = -(1/2)*z^2/(z*conjugate(z))^(3/2)-z^2/conjugate(z)^2

(26)

Eq (25) is expressed in terms of abs(z) = abs(z) while (26) is in terms of conjugate(z) = conjugate(z). Comparing as done in (14),

rhs((%diff(signum(z)+z*signum(z)^2, conjugate(z)) = -(1/2)*z^2/abs(z)^3-z^3*signum(z)/abs(z)^3)-(%diff(z/(z*conjugate(z))^(1/2)+z^2/conjugate(z), conjugate(z)) = -(1/2)*z^2/(z*conjugate(z))^(3/2)-z^2/conjugate(z)^2)) = 0

-(1/2)*z^2/abs(z)^3-z^3*signum(z)/abs(z)^3+(1/2)*z^2/(z*conjugate(z))^(3/2)+z^2/conjugate(z)^2 = 0

(27)

`assuming`([eval(-(1/2)*z^2/abs(z)^3-z^3*signum(z)/abs(z)^3+(1/2)*z^2/(z*conjugate(z))^(3/2)+z^2/conjugate(z)^2 = 0, z = a+I*b)], [a::real, b::real])

-(1/2)*(a+I*b)^2/(a^2+b^2)^(3/2)-(a+I*b)^4/(a^2+b^2)^2+(1/2)*(a+I*b)^2/((a+I*b)*(a-I*b))^(3/2)+(a+I*b)^2/(a-I*b)^2 = 0

(28)

simplify(-(1/2)*(a+I*b)^2/(a^2+b^2)^(3/2)-(a+I*b)^4/(a^2+b^2)^2+(1/2)*(a+I*b)^2/((a+I*b)*(a-I*b))^(3/2)+(a+I*b)^2/(a-I*b)^2 = 0)

0 = 0

(29)

NULL


 

Download Wirtinger_Derivatives.mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

 

Download FeynmanIntegrals.mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

1 2 3 4 5 6 7 Last Page 1 of 15