Advanced Search

MaplePrimes Posts

MaplePrimes Posts are for sharing your experiences, techniques and opinions about Maple, MapleSim and related products, as well as general interests in math and computing.

Latest Post
  • Latest Posts Feed
    •

    Special Theory of Relativity: Uniformly accelerated...

    by: Freddy Baudine 70 Maple 2022
    tensor physics special-relativity
    September 13 2022
    5  0

    Problem statement:
    Determine the relativistic uniformly accelerated motion, i.e. the rectilinear motion for which the acceleration w in the proper reference frame (at each instant of time) remains constant.

    As an application of the post presented by Dr Cheb Terrab in MaplePrimes on the principle of relativity ( found here ), we solve the problem stated on page 24 of Landau & Lifshitz book [1], which makes use of the relativistic invariant condition of the constancy of a four-scalar, viz., `w__μ`*w^mu where w^mu is the four-acceleration. This little problem exemplify beautifully how to use invariance in relativity. This is the so-called hyperbolic motion and we explain why at the end of this worksheet.

    NULL

    let's introduce the coordinate system, X = (x, y, z, tau)with tau = c*t 

    with(Physics)

    Setup(coordinates = [X = (x, y, z, tau)])

    [coordinatesystems = {X}]

    		 (1)

    %d_(s)^2 = g_[lineelement]

    %d_(s)^2 = -Physics:-d_(x)^2-Physics:-d_(y)^2-Physics:-d_(z)^2+Physics:-d_(tau)^2

    		 (2)

    NULL

    Four-velocity

     

    The four-velocity is defined by  u^mu = dx^mu/ds and dx^mu/ds = dx^mu/(c*sqrt(1-v^2/c^2)*dt) 

    Define this quantity as a tensor.

    Define(u[mu], quiet)

    The four velocity can therefore be computing using

    u[`~mu`] = d_(X[`~mu`])/%d_(s(tau))

    u[`~mu`] = Physics:-d_(Physics:-SpaceTimeVector[`~mu`](X))/%d_(s(tau))

    		(1.1)

    NULL

    As to the interval d(s(tau)), it is easily obtained from (2) . See Equation (4.1.5)  here with d(diff(tau(x), x)) = d(s(tau)) for in the moving reference frame we have that d(diff(x, x)) = d(diff(y(x), x)) and d(diff(y(x), x)) = d(diff(z(x), x)) and d(diff(z(x), x)) = 0.

     Thus, remembering that the velocity is a function of the time and hence of tau, set

    %d_(s(tau)) = d(tau)*sqrt(1-v(tau)^2/c^2)

    %d_(s(tau)) = Physics:-d_(tau)*(1-v(tau)^2/c^2)^(1/2)

    		(1.2)

    subs(%d_(s(tau)) = Physics[d_](tau)*(1-v(tau)^2/c^2)^(1/2), u[`~mu`] = Physics[d_](Physics[SpaceTimeVector][`~mu`](X))/%d_(s(tau)))

    u[`~mu`] = Physics:-d_(Physics:-SpaceTimeVector[`~mu`](X))/(Physics:-d_(tau)*(1-v(tau)^2/c^2)^(1/2))

    		(1.3)

    Rewriting the right-hand side in components,

    lhs(u[`~mu`] = Physics[d_](Physics[SpaceTimeVector][`~mu`](X))/(Physics[d_](tau)*(1-v(tau)^2/c^2)^(1/2))) = Library:-TensorComponents(rhs(u[`~mu`] = Physics[d_](Physics[SpaceTimeVector][`~mu`](X))/(Physics[d_](tau)*(1-v(tau)^2/c^2)^(1/2))))

    u[`~mu`] = [Physics:-d_(x)/(Physics:-d_(tau)*(-(v(tau)^2-c^2)/c^2)^(1/2)), Physics:-d_(y)/(Physics:-d_(tau)*(-(v(tau)^2-c^2)/c^2)^(1/2)), Physics:-d_(z)/(Physics:-d_(tau)*(-(v(tau)^2-c^2)/c^2)^(1/2)), 1/(-(v(tau)^2-c^2)/c^2)^(1/2)]

    		(1.4)

    Next we introduce explicitly the 3D velocity components while remembering that the moving reference frame travels along the positive x-axis

    NULL

    simplify(u[`~mu`] = [Physics[d_](x)/(Physics[d_](tau)*(-(v(tau)^2-c^2)/c^2)^(1/2)), Physics[d_](y)/(Physics[d_](tau)*(-(v(tau)^2-c^2)/c^2)^(1/2)), Physics[d_](z)/(Physics[d_](tau)*(-(v(tau)^2-c^2)/c^2)^(1/2)), 1/(-(v(tau)^2-c^2)/c^2)^(1/2)], {d_(x)/d_(tau) = v(tau)/c, d_(y)/d_(tau) = 0, d_(z)/d_(tau) = 0}, {d_(x), d_(y), d_(z)})

    u[`~mu`] = [v(tau)/(c*((c^2-v(tau)^2)/c^2)^(1/2)), 0, 0, 1/(-(v(tau)^2-c^2)/c^2)^(1/2)]

    		(1.5)

    Introduce now this explicit definition into the system

    Define(u[`~mu`] = [v(tau)/(c*((c^2-v(tau)^2)/c^2)^(1/2)), 0, 0, 1/(-(v(tau)^2-c^2)/c^2)^(1/2)])

    {Physics:-Dgamma[mu], Physics:-Psigma[mu], Physics:-d_[mu], Physics:-g_[mu, nu], u[mu], w[`~mu`], w__o[`~mu`], Physics:-LeviCivita[alpha, beta, mu, nu], Physics:-SpaceTimeVector[mu](X)}

    		(1.6)

    NULL

    Computing the four-acceleration

     

    This quantity is defined by the second derivative w^mu = d^2*x^mu/ds^2 and d^2*x^mu/ds^2 = du^mu/ds and du^mu/ds = du^mu/(c*sqrt(1-v^2/c^2)*dt)

    Define this quantity as a tensor.

    Define(w[mu], quiet)

    Applying the definition just given,

    w[`~mu`] = d_(u[`~mu`])/%d_(s(tau))

    w[`~mu`] = Physics:-d_[nu](u[`~mu`], [X])*Physics:-d_(Physics:-SpaceTimeVector[`~nu`](X))/%d_(s(tau))

    		(2.1)

    Substituting for d_(s(tau))from (1.2) above

    subs(%d_(s(tau)) = Physics[d_](tau)*(1-v(tau)^2/c^2)^(1/2), w[`~mu`] = Physics[d_][nu](u[`~mu`], [X])*Physics[d_](Physics[SpaceTimeVector][`~nu`](X))/%d_(s(tau)))

    w[`~mu`] = Physics:-d_[nu](u[`~mu`], [X])*Physics:-d_(Physics:-SpaceTimeVector[`~nu`](X))/(Physics:-d_(tau)*(1-v(tau)^2/c^2)^(1/2))

    		(2.2)

    Introducing now this definition (2.2)  into the system,

    Define(w[`~mu`] = Physics[d_][nu](u[`~mu`], [X])*Physics[d_](Physics[SpaceTimeVector][`~nu`](X))/(Physics[d_](tau)*(1-v(tau)^2/c^2)^(1/2)), quiet)

    lhs(w[`~mu`] = Physics[d_][nu](u[`~mu`], [X])*Physics[d_](Physics[SpaceTimeVector][`~nu`](X))/(Physics[d_](tau)*(1-v(tau)^2/c^2)^(1/2))) = TensorArray(rhs(w[`~mu`] = Physics[d_][nu](u[`~mu`], [X])*Physics[d_](Physics[SpaceTimeVector][`~nu`](X))/(Physics[d_](tau)*(1-v(tau)^2/c^2)^(1/2))))

    w[`~mu`] = Array(%id = 36893488148327765764)

    		(2.3)

    Recalling that tau = c*t, we get

    "PDETools:-dchange([tau=c*t],?,[t],params=c)"

    w[`~mu`] = Array(%id = 36893488148324030572)

    		(2.4)

    Introducing anew this definition (2.4)  into the system,

    "Define(w[~mu]=rhs(?),redo,quiet):"

    NULL

    In the proper referential, the velocity of the particle vanishes and the tridimensional acceleration is directed along the positive x-axis, denote its value by `#msub(mi("w"),mn("0"))`

    Hence, proceeding to the relevant substitutions and introducing the corresponding definition into the system, the four-acceleration in the proper referential reads

      "Define(`w__o`[~mu]= subs(v(t)=`w__0`, v(t)=0,rhs(?)),quiet):"

    w__o[`~mu`] = TensorArray(w__o[`~mu`])

    w__o[`~mu`] = Array(%id = 36893488148076604940)

    		(2.5)

    NULL

    The differential equation solving the problem

     

    NULL``

    Everything is now set up for us to establish the differential equation that will solve our problem. It is at this juncture that we make use of the invariant condition stated in the introduction.

    The relativistic invariant condition of uniform acceleration must lie in the constancy of a 4-scalar coinciding with `w__μ`*w^mu  in the proper reference frame.

    We simply write the stated invariance of the four scalar (d*u^mu*(1/(d*s)))^2 thus:

    w[mu]^2 = w__o[mu]^2

    w[mu]*w[`~mu`] = w__o[mu]*w__o[`~mu`]

    		(3.1)

    TensorArray(w[mu]*w[`~mu`] = w__o[mu]*w__o[`~mu`])

    (diff(v(t), t))^2*c^2/(v(t)^2-c^2)^3 = -w__0^2/c^4

    		(3.2)

    NULL

    This gives us a first order differential equation for the velocity.

     

    Solving the differential equation for the velocity and computation of the distance travelled

     

    NULL

    Assuming the proper reference frame is starting from rest, with its origin at that instant coinciding with the origin of the fixed reference frame, and travelling along the positive x-axis, we get successively,

    NULL

    dsolve({(diff(v(t), t))^2*c^2/(v(t)^2-c^2)^3 = -w__0^2/c^4, v(0) = 0})

    v(t) = t*c*w__0/(t^2*w__0^2+c^2)^(1/2), v(t) = -t*c*w__0/(t^2*w__0^2+c^2)^(1/2)

    		(4.1)

    NULL

    As just explained, the motion being along the positive x-axis, we take the first expression.

    [v(t) = t*c*w__0/(t^2*w__0^2+c^2)^(1/2), v(t) = -t*c*w__0/(t^2*w__0^2+c^2)^(1/2)][1]

    v(t) = t*c*w__0/(t^2*w__0^2+c^2)^(1/2)

    		(4.2)

    This can be rewritten thus

    v(t) = w__0*t/sqrt(1+w__0^2*t^2/c^2)

    v(t) = w__0*t/(1+w__0^2*t^2/c^2)^(1/2)

    		(4.3)

    It is interesting to note that the ultimate speed reached is the speed of light, as it should be.

    `assuming`([limit(v(t) = w__0*t/(1+w__0^2*t^2/c^2)^(1/2), t = infinity)], [w__0 > 0, c > 0])

    limit(v(t), t = infinity) = c

    		(4.4)

    NULL

    The space travelled is simply

    x(t) = Int(rhs(v(t) = w__0*t/(1+w__0^2*t^2/c^2)^(1/2)), t = 0 .. t)

    x(t) = Int(w__0*t/(1+w__0^2*t^2/c^2)^(1/2), t = 0 .. t)

    		(4.5)

    `assuming`([value(x(t) = Int(w__0*t/(1+w__0^2*t^2/c^2)^(1/2), t = 0 .. t))], [c > 0])

    x(t) = c*((t^2*w__0^2+c^2)^(1/2)-c)/w__0

    		(4.6)

    expand(x(t) = c*((t^2*w__0^2+c^2)^(1/2)-c)/w__0)

    x(t) = c*(t^2*w__0^2+c^2)^(1/2)/w__0-c^2/w__0

    		(4.7)

    This can be rewritten in the form

    x(t) = c^2*(sqrt(1+w__0^2*t^2/c^2)-1)/w__0

    x(t) = c^2*((1+w__0^2*t^2/c^2)^(1/2)-1)/w__0

    		(4.8)

    NULL

    The classical limit corresponds to an infinite velocity of light; this entails an instantaneous propagation of the interactions, as is conjectured in Newtonian mechanics.
    The asymptotic development gives,

    lhs(x(t) = c^2*((1+w__0^2*t^2/c^2)^(1/2)-1)/w__0) = asympt(rhs(x(t) = c^2*((1+w__0^2*t^2/c^2)^(1/2)-1)/w__0), c, 4)

    x(t) = (1/2)*w__0*t^2+O(1/c^2)

    		(4.9)

    As for the velocity, we get

    lhs(v(t) = t*c*w__0/(t^2*w__0^2+c^2)^(1/2)) = asympt(rhs(v(t) = t*c*w__0/(t^2*w__0^2+c^2)^(1/2)), c, 2)

    v(t) = t*w__0+O(1/c^2)

    		(4.10)

    Thus, the classical laws are recovered.

    NULL

    Proper time

     

    NULL

    This quantity is given by "t'= ∫ dt sqrt(1-(v^(2))/(c^(2)))" the integral being  taken between the initial and final improper instants of time

    Here the initial instant is the origin and we denote the final instant of time t.

    NULL

    `#mrow(mi("t"),mo("′"))` = Int(sqrt(1-rhs(v(t) = w__0*t/(1+w__0^2*t^2/c^2)^(1/2))^2/c^2), t = 0 .. t)

    `#mrow(mi("t"),mo("′"))` = Int((1-w__0^2*t^2/((1+w__0^2*t^2/c^2)*c^2))^(1/2), t = 0 .. t)

    		(5.1)

    Finally the proper time reads

    `assuming`([value(`#mrow(mi("t"),mo("′"))` = Int((1-w__0^2*t^2/((1+w__0^2*t^2/c^2)*c^2))^(1/2), t = 0 .. t))], [w__0 > 0, c > 0, t > 0])

    `#mrow(mi("t"),mo("′"))` = arcsinh(t*w__0/c)*c/w__0

    		(5.2)

    When proc (t) options operator, arrow; infinity end proc, the proper time grows much more slowly than t according to the law

    `assuming`([lhs(`#mrow(mi("t"),mo("′"))` = arcsinh(t*w__0/c)*c/w__0) = asympt(rhs(`#mrow(mi("t"),mo("′"))` = arcsinh(t*w__0/c)*c/w__0), t, 1)], [w__0 > 0, c > 0])

    `#mrow(mi("t"),mo("′"))` = (ln(2*w__0/c)+ln(t))*c/w__0+O(1/t^2)

    		(5.3)

    combine(`#mrow(mi("t"),mo("′"))` = (ln(2*w__0/c)+ln(t))*c/w__0+O(1/t^2), ln, symbolic)

    `#mrow(mi("t"),mo("′"))` = ln(2*t*w__0/c)*c/w__0+O(1/t^2)

    		(5.4)

    NULL

    Evolution of the four-acceleration of the moving frame as observed from the fixed reference frame

     

    NULL

    To obtain the four-acceleration as a function of time, simply substitute for the 3-velocity (4.3)  in the 4-acceleration (2.4)

    " simplify(subs(v(t) = w__0*t/(1+w__0^2*t^2/c^2)^(1/2),?),symbolic)"

    w[`~mu`] = Array(%id = 36893488148142539108)

    		(6.1)

    " w[t->infinity]^( mu)=map(limit,rhs(?),t=infinity) assuming `w__0`>0,c>0"

    `#msubsup(mi("w"),mrow(mi("t"),mo("→"),mo("∞")),mrow(mo("⁢"),mo("⁢"),mi("μ",fontstyle = "normal")))` = Array(%id = 36893488148142506460)

    		(6.2)

    We observe that the non-vanishing components of the four-acceleration of the accelerating reference frame get infinite while those components in the moving reference frame keep their constant values . (2.5)

    NULL

    Evolution of the three-acceleration as observed from the fixed reference frame

     

    NULL

    This quantity is obtained simply by differentiating the velocity v(t)given by  with respect to the time t.

     

    simplify(diff(v(t) = w__0*t/(1+w__0^2*t^2/c^2)^(1/2), t), size)

    diff(v(t), t) = w__0/(1+w__0^2*t^2/c^2)^(3/2)

    		(7.1)

    Here also, it is interesting to note that the three-acceleration tends to zero. This fact was somewhat unexpected.

    map(limit, diff(v(t), t) = w__0/(1+w__0^2*t^2/c^2)^(3/2), t = infinity)

    limit(diff(v(t), t), t = infinity) = 0

    		(7.2)

    NULL

    At the beginning of the motion, the acceleration should be w__0, as Newton's mechanics applies then

    NULL

    `assuming`([lhs(diff(v(t), t) = w__0/(1+w__0^2*t^2/c^2)^(3/2)) = series(rhs(diff(v(t), t) = w__0/(1+w__0^2*t^2/c^2)^(3/2)), t = 0, 2)], [c > 0])

    diff(v(t), t) = series(w__0+O(t^2),t,2)

    		(7.3)

    NULL

    Justification of the name hyperbolic motion

     

    NULL

    Recall the expressions for x and diff(t(x), x)and obtain a parametric description of a curve, with diff(t(x), x)as parameter. This curve will turn out to be a hyperbola.

    subs(x(t) = x, x(t) = c^2*((1+w__0^2*t^2/c^2)^(1/2)-1)/w__0)

    x = c^2*((1+w__0^2*t^2/c^2)^(1/2)-1)/w__0

    		(8.1)

    `#mrow(mi("t"),mo("′"))` = arcsinh(t*w__0/c)*c/w__0

    `#mrow(mi("t"),mo("′"))` = arcsinh(t*w__0/c)*c/w__0

    		(8.2)

    The idea is to express the variables x and t in terms of diff(t(x), x).

     

    isolate(`#mrow(mi("t"),mo("′"))` = arcsinh(t*w__0/c)*c/w__0, t)

    t = sinh(`#mrow(mi("t"),mo("′"))`*w__0/c)*c/w__0

    		(8.3)

    subs(t = sinh(`#mrow(mi("t"),mo("′"))`*w__0/c)*c/w__0, x = c^2*((1+w__0^2*t^2/c^2)^(1/2)-1)/w__0)

    x = c^2*((1+sinh(`#mrow(mi("t"),mo("′"))`*w__0/c)^2)^(1/2)-1)/w__0

    		(8.4)

    `assuming`([simplify(x = c^2*((1+sinh(`#mrow(mi("t"),mo("′"))`*w__0/c)^2)^(1/2)-1)/w__0)], [positive])

    x = c^2*(cosh(`#mrow(mi("t"),mo("′"))`*w__0/c)-1)/w__0

    		(8.5)

    We now show that the equations (8.3) and (8.5) are parametric equations of a hyperbola with parameter the proper time diff(t(x), x)

     

    Recall the hyperbolic trigonometric identity

    cosh(`#mrow(mi("t"),mo("′"))`*w__0/c)^2-sinh(`#mrow(mi("t"),mo("′"))`*w__0/c)^2 = 1

    cosh(`#mrow(mi("t"),mo("′"))`*w__0/c)^2-sinh(`#mrow(mi("t"),mo("′"))`*w__0/c)^2 = 1

    		(8.6)

    Then isolating the sinh and the cosh from equations (8.3) and (8.5),

    NULL

    isolate(t = sinh(`#mrow(mi("t"),mo("′"))`*w__0/c)*c/w__0, sinh(`#mrow(mi("t"),mo("′"))`*w__0/c))

    sinh(`#mrow(mi("t"),mo("′"))`*w__0/c) = t*w__0/c

    		(8.7)

    isolate(x = c^2*(cosh(`#mrow(mi("t"),mo("′"))`*w__0/c)-1)/w__0, cosh(`#mrow(mi("t"),mo("′"))`*w__0/c))

    cosh(`#mrow(mi("t"),mo("′"))`*w__0/c) = x*w__0/c^2+1

    		(8.8)

    and substituting these in (8.6) , we get the looked-for Cartesian equation

     

    subs(sinh(`#mrow(mi("t"),mo("′"))`*w__0/c) = t*w__0/c, cosh(`#mrow(mi("t"),mo("′"))`*w__0/c) = x*w__0/c^2+1, cosh(`#mrow(mi("t"),mo("′"))`*w__0/c)^2-sinh(`#mrow(mi("t"),mo("′"))`*w__0/c)^2 = 1)

    (x*w__0/c^2+1)^2-w__0^2*t^2/c^2 = 1

    		(8.9)

    NULL

    This is the Cartesian equation of a hyperbola, hence the name hyperbolic motion

    NULL

    Reference

     

    [1] Landau, L.D., and Lifshitz, E.M. The Classical Theory of Fields, Course of Theoretical Physics Volume 2, fourth revised English edition. Elsevier, 1975.

    NULL

    Download Uniformly_accelerated_motion.mw

    Maple Conference 2022 Creative Works Deadline...

    by: John May 2941 Maple , Maple Learn
    September 13 2022
    2  0

    This is a friendly reminder that the deadline for submissions for this year's Maple Conference Creative Works Exhibit is fast approaching!

    If you are looking for inspiration, you can take a look at the writeup of the works that were featured last year in this write up in the most recent issue of Maple Transations.

    Also, don't forget that you can also submit art made in Maple Learn for a special exhibit alongside the main gallery.

    Maple Learn Art for the Maple Conference

    by: Pleiades Chambers 395 Maple Learn
    education conference example-gallery
    September 09 2022
    1  0

    If you haven’t seen the posts already, the Maple Conference is coming up on the 2nd and 3rd of November! Last year’s art competition was very popular, so this year, not only are we holding the Maple Art and Creative Works Exhibit again, but we’ve decided to extend the art competition to include a Maple Learn Art Showcase!

    You may be wondering what math art can be created in Maple Learn, and what the requirements are for the conference. Let’s address the first question first.

    The best way to learn what kind of math art can be made is by taking a look at our Maple Learn Art document collection! This collection is in the Maple Learn document gallery, and includes art created by users with different levels of math and Maple Learn knowledge.

    Many examples of art are shown in the collection, but take a look at this art piece, which shows a fun character made with functions!

                                              

    We not only have static art, but animations as well. Take a look at this document, which shows an animated flower and bee, all created with math and Maple Learn.

     

    Now for the conference requirements. The submission requirement date is October 14th 2022, and there’s only one criterion for submission:

    • Art must be created in Maple Learn, and submissions must include the Maple Learn document.

     

    Feel free to include any extra information about yourself and your artwork directly in the document. You can share your submission by using the share icon in the top right of the Maple Learn UI. This will create a URL, which can be sent to gallery@maplesoft.com. Don’t forget to include your name in the emailed submission! Please contact us if you’re unsure about any of the criteria, or if you have any other questions!

    It may seem overwhelming, but remember: submitting something gives you a chance to share your art with the world and not submitting removes that chance! If you'd like more information about the Maple Learn Art Showcase or the Maple Art and Creative Works Exhibit, please check out our page on submissions for the art gallery on the Maplesoft website, or check out this example submission. See you all next time!

    Proceedings of the Maple Conference 2021 has been...

    by: rcorless 710 Maple
    education conference mapletransactions
    September 07 2022
    3  0

    Paulina Chin of Maplesoft and I are pleased to annouce Maple Transactions Volume 2 Issue 1, the Proceedings of the 2021 Maple Conference.

    Articles can be found at mapletransactions.org

    Some articles are written directly in Maple and are published via the Maple Cloud.  There is also a Demo Video by Michael Monagan of his new GCD code.  There are articles on Math Education, on Applications of Maple, on software, and on mathematics research.  We draw particular attention to the article by Veselin Jungic, 3M Teaching Fellow at SFU and a Fellow of the Canadian Math Society, on Indigenising mathematics.  We hope that, as members of the Maple Community, you find much of interest.

    Best wishes,

    Rob Corless, Editor-in-Chief

    Maple Transactions

    Forest of ethnomathematics and its root. Colourful natural trees growing in a forest above ground while below ground is a colourful mathematical tree going to a single glowing root

    New Generalized Unit Vectors in Physics:-Vectors

    by: ecterrab 14455 Maple
    volume surface vector-calculus
    September 06 2022
    6  1


     

    New generalized unit vectors in Physics:-Vectors

     

    The Physics:-Vectors package, written many years ago to teach Vector Analysis to 1st year undergrad students in Physics courses, introduces several things that are unique in computer algebra software. Briefly, this package has the ability to compute sums, dot and cross products, and differentiation with

    • 

    abstract vectors, like `#mover(mi("A"),mo("→"))` or `#mover(mi("A"),mo("→"))`(x, y, z), symbols or functions with an arrow on top that indicates to the system that they are vectors, not scalars;
    • 

    projected vectors of algebraic (non-matrix) type in any of the Cartesian, cylindrical or spherical basis and/or associated systems of coordinates, including for that purpose an implementation of the corresponding unit vectors of the three bases;
    • 

    abstract or projected differential operators that involve Nabla, Gradient, Divergence, Laplacian and Curl;
    • 

    inert vectors or vectorial differential operators, including related expansion of operations and simplification; 
    • 

    path, surface and volume vector integrals.

     

    In addition to the above, the display is as in textbooks, the input resembles paper and pencil handwriting, and examples of the use of Physics:-Vectors in Vector Analysis are presented in the Physics,Examples page.

     

    Download New_generalized_unit_vectors.mw

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

    Einstein's principle of relativity

    by: ecterrab 14455 Maple
    physics special-relativity einstein
    September 05 2022
    9  1

    Einstein's principle of relativity

     

    The main difference between Newtonian mechanics and the mechanics based on Einstein's principle of relativity is that in the latter the velocity of light, c, is the same in all inertial reference systems. Therefore, when comparing the velocity of an object measured in two reference systems 1 and 2 that are moving relative to each other, the Newtonian rule of addition of velocities, v__2_ = v__1_+v__R_, where v__R_ is the velocity of one system with respect to the other one, is not valid; if it were, the speed v__1_ and v__2_ of light in the systems 1 and 2 would not be the same. This introduces surprising conceptual consequences, and algebraic complications in the formulas relating the values of measurements, in the systems 1 and 2, of time, space and everything else that is related to that.

     

    This post is thus about Einstein's principle of relativity and the consequences of the velocity of light being the same in all inertial reference systems. Although the topic is often considered advanced, the concepts, as shocking as they are, are easy to understand, and the algebra is still tractable in simple terms. The presentation, following Landau & Lifshitz [1], Chapter 1, is at a basic level, with no prerequisite expertise required, and illustrates well how to handle the basic algebraic aspects of special relativity using computer algebra.

     

    Finally, it seems to me not useful to just present the algebra when the concepts behind Einstein's theory are straightforward and surprising. For that reason, the short sections 1 and 2 are all about these concepts, and the algebra only starts in section 3, with the Lorentz transformations (which was recently the topic of a Mapleprimes post at a more advanced level ). To reproduce the computations shown in this worksheet, please install the Maplesoft Physics Updates v.1314 or any subsequent version.

     

    Download Einstens_principle_of_relativity.mw

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

     

    Concept Exploration with Maple Learn Documents...

    by: Pleiades Chambers 395 Maple Learn
    education biology interactive
    September 02 2022
    1  0

    Welcome back to another blog post, Maple Learn enthusiasts! Today we’re going to go through a concept and see what documents are available to help you learn the concept. What concept? Blood typing!

    You may have gotten your blood tested before, but do you know the science behind blood types? Have you ever thought about it, even? Well, if not, you’re in the right place! Let’s take a look at some of the concepts you need to know before looking deeper into blood typing.

    First, what are genotypes and phenotypes? Did you notice those terms had links attached to them? We have Maple Learn documents on this topic, shown below. Take a moment to read them over before we continue, but to summarize: A genotype is the genetic makeup within a trait, whereas a phenotype is the displayed trait. Another important term to recognize is allele – the specific variations of genes that are involved in the genotype.

    The next thing to review is Punnett Squares, and the document is also shown below. Review this one too, to learn how to examine genetic combinations! Take a good look at the tables being used, as well, as an example of a creative use of a typically mathematical feature.

    Now let’s finally dig into the blood types. Humans have 4 different blood types (excluding the Rhesus factor – but we won’t be talking about that today): A, B, AB, and O. A and B alleles are represented with an “I” with a superscript A or B, respectively. O is represented with “i”. Remember, a full genotype has two alleles, so someone with the blood type O would be represented as “ii” in their genotype. Can you read the Punnett Square below?

    To extend your learning, take a look at our blood typing quiz! This quiz allows you to practice making Punnett Squares on paper, in order to figure out the likelihood of a phenotype (the blood type) given the genotype of the parents.

    We hope you enjoyed the concept walkthrough! Please let us know if there are any other concepts you’d like to see explained through Maple Learn documents. Until next time!

    New coordinate-system labels in Physics

    by: ecterrab 14455 Maple
    tensor relativity physics
    August 25 2022
    9  0

    Notation is one of the most important things to communicate with others in science. It is remarkable how many people use or do not use a computer algebra package just because of its notation. For those reasons, in the context of the Physics package, strong emphasis is put on using textbook notation as much as possible regarding input and output, including, for that purpose, as people here know, significant developments in Maple typesetting.

    Still, for historical reasons, when using the Physics package, the labels used to refer to a coordinate system had been a single Capital Letter, as in X, Y, ...It was not possible to use, e.g. X', or x.

    That has changed. Starting with the Maplesoft Physics Updates v.1308, any symbol can be used as a coordinate system label. The lines below demo this change.

     

    Download new_coordinates_labels.mw

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

    A salute to all math teachers

    by: Karishma 805 Maple Learn
    education interactive
    August 24 2022
    2  0

    As we head back to school, I want to take a moment to thank all the math teachers out there who take on the demanding yet overlooked task of educating our children, teenagers, and young people. 

    I'm where I am today because my calculus teacher, Prof. Srinivasan, was unwavering in her belief that my classmates and I could master any math topic, including calculus. Her conviction in me gave me the confidence to believe I could 'do' math. While Prof. Srinivasan made teaching look easy, I'm acutely aware that teaching math is no easy feat. Speaking with math educators regularly, I can appreciate how challenging teaching math is today compared to a decade ago. Not only do they have to teach the subject, but they must be able to teach it in-person and online, to a group of students that may not be up to speed on the prerequisite material, and in an era where disruptive technologies vie for their student's attention. No wonder math educators are so anxious about returning to the classroom this fall!

    And while I wish I could abracadabra your worries away, what I can do is offer you the opportunity to use Maple Learn, a tool built to support the utopian vision of a world where all students love math. A world where math is for everyone, not just the gifted, and the purpose of math class is to explore and marvel at the wonders of the universe, not just get to the correct answer.

    Slightly more concretely, Maple Learn is a flexible interactive environment for exploring concepts, solving problems, and creating rich online math content. I've seen educators use Maple Learn to help their students: 

    I’ve talked to lots of instructors, in math, and in courses like economics and physics that use math, who have lots of ideas of how to engage their students and deepen their understanding through interactive online activities. What they don’t have are the tools, programming experience, deployment platform, or time to implement their vision. Fortunately, Maple Learn makes it incredibly easy to develop and share your own content, and all you need are your ideas and a web browser. But you don’t need to start from scratch. You can choose from an extensive, constantly growing repository of ready-made, easily customizable content covering a wide range of topics. I think you’ll be pleasantly surprised by how easy it is, but since we are well aware that instructors are extremely busy people, we also have content development services that can help you transform your static content into interactive lessons.

    If you haven't looked at Maple Learn, or it's been a while since you last saw it, you can visit Reinventing Math Education with Maple Learn for more information, including an upcoming webinar you might be interested in attending and a special offer on Maple Learn for Maple campuses. And if you ever want to discuss ways Maple Learn might help you, or have ideas on how to make it better, please reach out. I'm always up for good conversation. 

    And for all the dedicated teachers who are taking a deep breath and heading back into the classroom this fall, thank you.

    Chemistry Documents in Maple Learn- Average Atomic...

    by: Pleiades Chambers 395 Maple Learn
    August 19 2022
    2  0

    Welcome back to another document walkthrough! Today, I thought we’d take a look at a non-math example, like chemistry. The document we’ll be using is “Finding Average Atomic Mass”. Before we get too into it, I’d like to define some terms. Average atomic mass is defined as the weighted average mass of all isotopes of an element. An elemental isotope can be thought of as a “version” of the element – The same element at its core, but having different weight or other properties. This is due to having the same number of protons, but a different number of neutrons.

    This document is, of course, about finding that average atomic mass. See the picture below for our problem, which states the element, the isotopes, and their separate masses and relative abundance.

    The average atomic mass can then be calculated using sum notation. To calculate, take the weighted mean of the isotopes’ atomic masses, as shown in the overview section of the Average Atomic Mass document.

    Once you’ve tried solving the problem yourself, take a look at the answer in group four, or one of the practice problems in group five. We have three examples on this topic (Average Atomic Mass Example 1, Average Atomic Mass Example 2, and Average Atomic Mass Example 3), so take a look at them all!

    I hope you enjoyed learning just a bit of chemistry today, and let us know in the comments if there are any documents you’d specifically like to see explained, or any topics you’d like us to talk about!

     

    Maple Learn Collection Dive – Derivatives

    by: Pleiades Chambers 395 Maple Learn
    derivative calculus differentiation
    August 12 2022
    2  0

    Welcome back to another post on the Maple Learn Calculus collection! Previously on this series we looked at the Limit subcollection, and today we are going to look at the Derivative subcollection in the Maple Learn Document Gallery.

    There are many different types of documents in this sub collection, so let’s take a look at one of them. We’ll start with the very first question people ask when learning about derivatives: What is a derivative?

     

    This document starts us off with an example of f(x):=x2. The example provides the background information for the rest of the document, and a visualization with a slider.

    Then, we define both the Geometric and Algebraic definition of a derivative. This allows us to understand the concept in two different ways, a very useful thing for students as they explore other topics within calculus.  

    Finally, the document suggests two more documents for future learning: Derivatives: Notation, for more information on the notation used in derivatives, and the Formal Definition of a Derivative document, for more information on how derivatives are formally defined and derived. Make sure to check them out too!

    Now, that’s just the start. We’ve got practice problems, definitions and visualizations of rules, information on points without derivatives, and much more. They’re useful for both new learning and as a refresher, so take a look!

    We can’t wait to see you another time for when we dive into Derivative documents. Let us know after the Calculus collection showcase blog posts if there’s another collection you’d like to see showcased!

     

    Possible incorrect results when modeling a telescopic...

    by: C_R 3327 MapleSim
    August 10 2022
    1  3

     

    Combing a Prismatic Joint component with an Elasto Gap component does not always provide correct results. Incorrectly combined (red mass below), a force is generated although the distance between the flanges is greater than the relaxed spring length. A force is exerted (instead of no force is exerted as stated here) on the mass which leads to a smaler deflection (expected are 9.81 m).

    This happened to me although I connected flange_a to flange_a and flange_b to flange_b in configruation A bellow. Configuration B works with inverted flanges and configuration C works with inverted unit vector of the prismatic joint. By reversing the direction of gravity, configuration A becomes a valid configuration and configurations B and C become invalid configurations.

    It seems that in invalid configruations the value of the  flange distance s_rel can have a large magnitude but is negative in sign which generates significant forces although there is no contact of flanges.

    So far for the observations.

     

    Would a change of the contact condition

    prevent invalid configurations or do we have to live with it for principal reasons that I am over looking?

    If so, I don't see a foolproof method to avoid invalid configurations. Instead, I can only suggest measuring the flange distance of the Elasto Gap component as in the attached. If negative values of large amplitude occur, the configuration is invalid.

    Assuming that a beginner would connect intuetively flange_a to flange_a and flange_b to flange_b, there is a chance of 50% that the configuration is invalid (A instead of C). This is too much to be acceptable, especially since verifying results in complex assemblies is often not possible.

    It is worth noting that the contact condition comes from the underlying Modelica component and not from MapleSoft.

    Prismatic_Joint_with_Elasto_Gap.msim

    Maple in Social Science

    by: Lenin Araujo Castillo 1790 Maple 2022
    education
    August 05 2022
    2  0

    UNIVERSIDAD AUTÓNOMA METROPOLITANA
    UNIDAD XOCHIMILCO

    15º Foro de Investigación de las Matemáticas Aplicadas a las Ciencias Sociales "Reflexiones sobre Educación y Matemáticas”,

    "Learning of mathematical functions using applications with Maple, for students of Social Sciences"

    The students of the first cycles have a low level of learning in the subject of functions, and the arrival of the pandemic worsened the understanding of this content. Increasing the use of ICT in great magnitude improving learning.
    To determine the relationship between learning and mathematical functions using applications with Maple, for students of Social Sciences. The experimental method was used using the scientific software Maple applied to students of Social Sciences.

    In Spanish.

     

    Lenin Araujo Casillo

    Ambassador of Maple

     

     

    Deriving 4D relativistic Lorentz transformations

    by: ecterrab 14455 Maple
    transformation relativity 4-dimensional
    August 04 2022
    7  0

    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

    Maple Flow 2022.1 update

    by: Samir Khan 2091 Maple Flow
    engineering update
    August 04 2022
    4  1

    We've just released Maple Flow 2022.1. We've squeezed in a few new features as requested by our users - I'll describe them below.

    Before we get to that, I'd like to give everyone an open invitation to grab a Maple Flow trial - I'd love to know what you think. I'm fanatically devoted to making Flow better, but I can only do that if you give me your feedback.

    You can specify if you want your results to be globally displayed using engineering, scientific, or fixed notation

    Supporting images can be cut and pasted from another source directly into Maple Flow using standard clipboard operations.

    You can now insert a time stamp in headers and footers. And you can optionally place a border around the header, footer or body of the page.

    New content in the help system makes it easier to get started with advanced features, including techniques for optimization and signal processing.

    Go here to learn more...and don't forget to grab a trial.

     

    First 17 18 19 20 21 22 23 Last Page 19 of 305