Product Tips & Techniques

Tips and Tricks on how to get the most about Maple and MapleSim

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

Yes, you read that right! Steps documents are a feature in Maple Learn that we wanted to highlight this week, as they can provide great use in understanding concepts and solving problems. Within them, they can show all steps to solve a problem, including reminders of any formulas used! They can be found at the homepage for steps documents. A list of all can be found below the image, with links.

All steps documents:

All of our documents follow the same format, which I’ll show you using 3 different documents: Derivatives Steps, Factoring Steps, and Matrix Determinant Steps. They will be shown from left to right in that order, so you can see the different steps and how they work.

 

The first thing you’ll see on any steps document is the place to enter the equation. Each equation can be entered in the appropriate box, in different styles to fit your needs and the problem asked.

Then, you click on the show steps button, which is the same for all of the documents:

This is where the magic happens. The steps will appear line by line, in great detail. The actual steps are generated by Maple, and presented in Maple Learn through scripting. Because of this, please don’t click off the group the steps appear in, or they’ll appear in the new group as well!

There are many other steps documents than the ones we have here, and will be adding more as time goes on. Please keep an eye out, and enjoy the updates! We hope this was helpful to you all, and let us know if there are any other steps you’d like to see.

 

Today I’m here with a document walkthrough under the subject of graph theory! Do you know what an Eulerian path is? Have you ever tried to find one?

An Eulerian path is a path that uses every edge in the graph exactly once. Vertices can be revisited, just not the edges. There are mathematical ways to find an Eulerian path, but at the level of math I’m at, I just use my eyes!

                                                      

In the document Eulerian Paths Quiz, we focus on trying to find an Eulerian path. This document, created using Maple scripting, uses the click on plot feature, allowing you to click on the edges and check your answer. When an edge is clicked, it turns red, and feedback is given.

If you make a mistake, there are a few options. If the most recent edge chosen is the mistake, you can simply click on it again to undo the selection. However, if the mistake is several edges back, or you need to undo the whole thing, you can click the blue reset button.

                                                                                    

Once you’ve done one, you might want to try another graph. That’s why we have a try another button, to give you another random new graph.

We hope you enjoy this document! If you’re curious about how this document was scripted, you can see our script HERE. Please let us know if there are any specific documents you’d like as a walkthrough in the comments below, and check out our other graph theory documents.

For a long time I could not understand how to make a kinematic analysis of this device based on the coupling equations (like here). The equations were drawn up relative to the ends of the grips (horns), that is, relative to the coordinates of 4 points. That's 12 equations. But then only a finite number of mechanism positions take place (as shown by RootFinding[Isolate]). It turns out that there is no continuous transition between these positions. Then it is natural to assume that the movement can be obtained with the help of a small deformation. It seemed that if we discard the condition of a constant distance between the midpoints of the horns (this is the f7 equation at the very beginning), then this will allow us to obtain minimal distortion during movement. In fact, the maximum distortion during the movement was in the second decimal place.
(It seemed that these guys came to a similar result, but analytically "Configuration analysis of the Schatz linkage" C-C Lee and J S Dai
Department of Tool and Die-Making Engineering, National Kaohsiung University of Applied Sciences, Kaohsiung, Taiwan Department of Mechanical Engineering, King’s College, University of London, UK)

The left racks are input.


The first text is used to calculate the trajectory, and the other two show design options based on the data received.
For data transfer, a disk called E is used.
Schatz_mechanism_2_0.mw
OF_experimental_1_part_3_Barrel.mw
OF_experimental_1_part_3.mw

 

Maple Learn is an incredibly powerful tool for math and plotting, but it is made even more powerful when used in combination with Maple! Using scripting tools in Maple, we can make use of hundreds of commands that can solve complex problems for us. In the example of the Lagrange calculator, we are able to use the Maple command LagrangeMultipliers to generate a plot of the two functions and the critical points, even including text feedback about the points.


Something like this seems like it would take hours and a lot of coding knowledge to create, but a simple Maple command generates the entire plot for us! Then, all we had to do was use a button to update the plot. Give it a try yourself in Maple, run the following command with two functions f and g of your choosing:

That’s all there is to it! We now have a complex 3D plot showing the Lagrange problem, something that can be difficult to visualize in multivariate calculus. If we want detailed feedback about the Lagrange problem values, simply change output to detailed from plot:

Check out the entire Maple document (.mw file) to see how the Learn page was generated and to try things out for yourself. This entire document uses the LagrangeMultipliers command, but Maple has hundreds more to experiment with, so the possibilities are virtually limitless!

Share your creations here on MaplePrimes and tag us in your posts.

Maple Learn Document: https://learn.maplesoft.com/doc/lagrange-multipliers-calculator-1biue2ben9

Maple .mw file: https://maple.cloud/app/5998067190071296/LagrangeCalculatorCritical?key=54CE05EC89B34E47984BC61C329A6E759658927BED02458095DA1F576CD93DB9

Maple Learn has a new face! We’ve changed our homepage to the document gallery, which some of you may have already noticed. This is a huge change, and we’re excited for it, as it places content front and center: the goal of Maple Learn. Don’t worry, getting to a blank document is still easy. There is a large orange button on the top right of the document gallery which says “start creating now”. This button will take you to a blank Maple Learn Document.

                                                                        

The most important reason for this change is to help new users get started. Seeing a blank document can sometimes be terrifying! With this new homepage, users can immediately begin looking through premade content, and get inspiration for their own documents.

 

The first document collection a user sees in the document gallery is still the same: Our featured collection. From there, we have the Maple Learn how-to documents, and then it’s into documents sorted by the overarching subject. Two examples of overarching subjects are Functions and Biology. And, if a user is interested in some of the more artistic sides of Maple Learn, we have our art collection available as well. There’s something for everyone in our gallery!

                             

Now that we’ve explained the largest change, let’s talk about some smaller ones too. Tables now can have row and column headings, allowing for a greater range of data to be represented. Along with that, we’ve added a correlation command to the context panel. Some bugs have also been fixed: Special characters now appear properly in the French and German galleries and scrollbars work over 3D plots.

 

We hope you enjoy the changes we’ve made. Please continue to report bugs and telling us about features you’d like to see!

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

Happy Friday everyone, and welcome to our third post about how you can use Maple Learn in non-math disciplines! Today, we’re going to talk about the Biology collection in Maple Learn. This was a recent addition to the Maple Learn document gallery.

Of course, there are too many documents in the Biology collection to talk about all of them. We’re going to talk about three documents today, and I’ll link to them as we go. Are you excited? I am!

First, let’s talk about the Introduction to Alleles and Genotype document. The current focus of our Biology collection is genetics. This document is therefore important to start with as it lays the foundation for understanding the rest of the documents. Using a visualization of a sperm cell and an egg cell, this document clearly explains what alleles and genotypes are, and how this presents in humans and other diploid organisms.

`

Next is the Introduction to Punnett Squares. Punnett squares are used to predict genotypes and the probability of those genotypes existing in an organism. They can be pretty fun, once you get the hang of them, and are simple to understand using this document. We use the table feature in Maple Learn to display the Punnett squares, which is quite a handy feature for visualizations.

Finally, although there are other introductory documents (Phenotypes, Dihybrid crosses), let’s take a look at the Blood Typing document! As you may know, there are four main blood types (when you exclude the positive or negative): A, B, AB, and O. However, there are only three alleles, due to codominance and other factors. Come check out how this works, and read the document yourself!

                                                                        

Our Biology collection is still growing, and we’d love to hear your input. Let us know in the comments of this post if there are any other document topics you’d like to see!

Last week, we took a look at the Chemistry documents in Maple Learn. After writing that post, I started thinking more about the types of documents we have in the document gallery. From there, I realized we’d made several updates to the Physics collection, and added a Biology collection, that I hadn’t written about yet! So, this week, we’ll be talking about the Physics collection, and next week, we’ll have a discussion about the Biology collection. Without further ado, let’s take a look!

First, let’s talk Kinematics. This collection has been around for a while now, and if you’ve looked at the Physics documents, you’ve likely seen it. We have documents for Displacement, Velocity, and Acceleration, Equations 1 to 4 for Kinematics, 1D motion, and 2D motion. Let’s take a look at the 2D motion example, shall we?

In this document, we explore projectile motion. You can use sliders to change the initial velocity and the height of a projectile, in order to see how they affect the object’s motion. Then, in group two, you can adjust the number of seconds after an object has been released in order to see how the velocity changes. The resulting graph is shown above this paragraph.

Next, we also have documents on Energy, Simple Harmonic Motion, and Waves (interference and harmonics). These documents were added over the last few months, and we’re excited to share them! Opening the document used as an example for wave harmonics (link provided again here), we’re immediately given a description of the important background knowledge, and then a visualization, shown below. This allows you to see how waves change based on the harmonics and over time.

Finally, we have documents on Electricity and Magnetism, Dynamics, and some miscellaneous documents, like our document on the inverse square law applied to Gravity. Within these document collections, we have quizzes, information, and many more visualizations!

The Physics collection is quite an interesting collection, we hope you enjoy! As with the Chemistry documents, please let us know if there’s any topics you’d like to see in our document gallery.

We have just released an update to Maple, Maple 2022.1.

Maple 2022.1 includes improvements to the math engine, Plot Builder, Print Layout mode, and more.  We strongly recommend that all Maple 2022 users install these updates.

This update is available through Tools>Check for Updates in Maple, and is also available from our website on the Maple 2022.1 download page, where you can also find more details.

In particular, please note that this update includes fixes to problems with Units:-Simple (here and here), evala, sum, and deleting tasks from a task template, all reported on MaplePrimes. As always, thanks for the feedback!

We are happy to announce that we released MapleSim 2022 today.

The MapleSim 2022 family of products offers improvements in modeling and connectivity, including many that are in direct response to customer requests. Improvements include:

  • Reduce diagram clutter by using “wireless” To-From blocks for a larger variety of signals
  • Easily create, customize, and fine-tune control valves with new components and tools in the hydraulics library
  • Expand modeling scope with improvements to several specialized libraries and toolboxes, including the MapleSim add-on products for Battery, Heat Transfer, and Web Handling
  • New productivity and connectivity features in MapleSim Insight,  a standalone product in the MapleSim family that gives machine builders powerful simulation-based debugging and 3-D visualization capabilities that connect directly to your automation tools

 

See What’s New in MapleSim 2022 for more information about these and other improvements.

Hello Maple Learn enthusiasts, of all disciplines! Do any of you study Chemistry, or simply enjoy it? Well, you’re in luck. We’re released a new collection of documents in the document gallery, all focused on Chemistry. Remember, Maple Learn isn’t just for math fields. We also have documents on Biology, Physics, Finance, and much more!

                                                                  

First, we have our new gas laws documents. These documents focus on Boyle’s law, Charles’ law, Gay-Lussac’s law, and Avogadro’s law. We also have documents on the Combined Gas law and the Ideal Gas law. Many of these laws also have example questions to go along with them, for your studying needs.

We also have documents on molar and atomic mass. One example for atomic mass teaches you to use the proper formulas (No spoilers for the answer here, folks!) using the material Hafnium and its five isotopes. Don’t know the approximate masses of the isotopes without looking them up? No worries, I don’t either! It’s in the question text, as a hint.

Finally, let’s take a look at the dilution documents. We have documents discussing the calculations, and some examples. In this document, there are both an example walking you through the steps, and a practice question for you to try yourself. Of course, the solution is included at the bottom of the document, but we encourage you to try the problem yourself first.

We hope you’re just as excited as us for the Chemistry collection! Like our other collections, the Chemistry collection is constantly being added to. If you have any ideas for future documents, or even just topics you’d like to see, let us know in the comments below.

Today is a very exciting day at Maplesoft! Yesterday, we released Sumzle on the Maple Calculator app. Of course, this might not mean anything to you yet, because, well, what is Sumzle? Don’t worry, we know you’re asking. So, without waiting any longer, let’s take a look.

Sumzle is a math game, inspired by the Wordle craze, where you attempt to guess an equation. Each guess:

  • Must include an equal sign
  • Must include up to two operators
  • May include a blank column

Sumzle’s interface looks like this:

After each guess, the tile’s colors change to reflect how correct the guess was. Green means that the tile is in the right spot, yellow means the tile is in the equation but the wrong spot, and grey means that it is not in the equation. Let me show you the progression of a game, on the Fun difficulty.

Sumzle can be played once a day on the free tier. For unlimited games, you can subscribe to Maple Calculator Premium or ask your friends to challenge you!

 

Math games are for everyone, and Sumzle has three levels of difficulty. Are you interested in the history of Sumzle? I sure am!

Sumzle was originally designed by Marek Krzeminski, a MapleSim developer. He had called it Mathie and showed the game to his colleagues here at Maplesoft. Well, we loved it!

After a few months of discussion and development, we tweaked the game to create Sumzle. Honestly, the hardest part was naming the game! We had so many great suggestions, such as Mathstermind and Addle. Eventually, we put it to a vote, and Sumzle rose above the rest.

We hope you enjoy the game, because Math not only matters, but is fun. Don’t forget to update your Maple Calculator app in order to receive that game, as otherwise you won’t be able to find it. Next time you need a break, we challenge you to a game of Sumzle!

A user found that the behaviour of calling a command from a library with a long form command name which invoked another command from that library with the short form name was unexpected:

restart;
ScientificConstants:-GetValue(Constant(g))

Error, (in ScientificConstants:-GetValue) `Constant(g)` is not a scientific constant object

 

 

 

We suggested to either

[Edit May 13 after Acer's improvements]

A) import the package such that all short form names of commands from the package are available in the Maple session and use the short form of both commands:

restart;
with(ScientificConstants):
GetValue(Constant(g));

9.80665

(1)

Download scientificConstantsGetValueShortFormsWithPackage.mw

or

B) use long forms for both command names:

restart;
ScientificConstants:-GetValue(ScientificConstants:-Constant(g))

9.80665

(1)

Download scientificConstantsGetValueLongFormLongForm.mw

or

C) to test that a long form command and a short form command work together, import the package for the short form command:

restart;
with(ScientificConstants):
ScientificConstants:-GetValue(Constant(g))

9.80665

(1)

Download scientificConstantsGetValueLongFormWithPackage.mw

Further details can be found in the article ?UsingPackages

Have you ever wanted to create practice problems and quizzes that use buttons and other features to support a student making their way to an answer, such as the following?

Let’s take a look at how you can use Maple 2022 to create documents like these that can be deployed in Maple Learn. I know I’ve always wanted to learn, so let’s learn together. All examples have a document that you can use to follow along, found here, in Maple Cloud.  

The most important command you’ll want to take a look at is ShareCanvas. This command generates a Maple Learn document. Make sure to remember that command, instead of ShowCanvas, so that the end result gives you a link to a document instead of showing the results in Maple. You’ll also want to make sure you load the DocumentTools:-Canvas subpackage using with(DocumentTools:- Canvas).

If you take a look at our first example, below, the code may seem intimidating. However, let’s break it down, I promise it makes sense!

with(DocumentTools:-Canvas);
cv := NewCanvas([Text("Volume of Revolution", fontsize = 24), "This solid of revolution is created by rotating", f(x) = cos(x) + 1, Text("about the y=0 axis on the interval %1", 0 <= x and x <= 4*Pi), Plot3D("Student:-Calculus1:-VolumeOfRevolution(cos(x) + 1, x = 0 .. 4*Pi, output = plot, caption=``)")]);
ShareCanvas(cv);

The key command is Plot3D. This plots the desired graph and places it into a Maple Learn document. The code around it places text and a math group containing the equation being graphed. 


Let’s take a look at IntPractice now. The next example allows a student to practice evaluating an integral.

with(Grading):
IntPractice(Int(x*sin(x), x, 'output'='link'));

 This command allows you to enter an integral and the variable of integration, and then evaluates each step a student enters on their way to finding a result. The feedback given on every line is incredibly useful. Not only will it tell you if your steps are right, but will let you know if your last line is correct, i.e if the answer is correct.

Finally, let’s talk about SolvePractice.

with(Grading):
SolvePractice(2*x + 3 = 6*x - 9, 'output' = 'link');

This command takes an equation, and evaluates it for the specified variable. Like the IntPractice command, this command will check your steps and provide feedback. The image below shows how this command looks in Maple 2022.

These commands are the stepping stones for creating practice questions in Maple Learn. We can do so much more in Maple 2022 scripting than I realized, so let’s continue to learn together!

Some other examples of scripted documents in the Maple Learn Document Gallery are our steps documents, this document on the Four Color Visualization Theorem, and a color by numbers. As you can see, there’s a lot that can be done with Maple Scripting.

 Let us know in the comments if you’d like to see more on Maple 2022 scripting and Maple Learn.

4 5 6 7 8 9 10 Last Page 6 of 66