Product Tips & Techniques

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

The first day of Maple Conference 2022 is coming up on November 2 and it's not too late to register! Please go to our conference home page and click on the "Register Now" button. This is a free virtual event open to all.

The schedule is available on the conference agenda page.

Come join us to see recent developments in research, education and applications, find out about new and upcoming features in our products, talk to Maplesoft staff and other members of the Maple community and view (and vote on) Maple and Maple Learn artwork.

We hope to see you at the conference!

We have just released the 2022.2 updates for Maple and MapleSim. These updates are freely available to all customers who have the 2022 version of these products.

Maple 2022.2 includes improvements to worksheet performance, the math engine, and more. As always, we recommend that all Maple 2022 users install this update. It is available through Tools>Check for Updates in Maple, and is also available from our website on the  Maple 2022.2 download page, where you can also find more details.

The MapleSim 2022.2 family of products offers an enhanced user experience through an expansion of the modeling libraries, a range of new productivity features, and several new options requested by users. See the MapleSim 2022.2 update page for details on new features, and for instruction on how to obtain your update.

Welcome back to another Maple Learn blog post! We know it is midterm season, and we’re here to help. Maple Learn can be used to study in many different ways, and I’m sure you’ve already tried some of them. One way is making your notes in Learn, or making your own examples, but have you taken a look at our document gallery? We have a wide range of subjects and types of documents, so let’s take a look at some documents!

I’m going to start by talking about the documents in the gallery which are content learning focused, then move into practice problems and a special document for studying.

First, let’s look at some calculus content learning documents! The calculus collection is our largest, reaching over 250 documents and still counting. The two documents I’ve picked from this category are our documents on the Fundamental Theorem of Calculus and a Visualization of Partial Derivatives. See a screenshot of the visualisations for each document below!

 

Are there other subjects you’d like to look at? Well, take a look at our list below!

Algebra: Double Vertical Asymptote Slider Graph

Graph Theory: Dijkstra’s Algorithm for Shortest Paths

Economics: Increase in Demand in a Market

Chemistry: Combined Gas Law Examples

Biology: Dihybrid Cross Punnett Squares

Physics: Displacement, Velocity, and Acceleration

We have many other subjects for documents, of course, but they wouldn’t fit in this post! Take a look at our entire document gallery for the others.

Another class of documents we have are the practice problems. Perfect for studying, we have practice problems ranging from practicing the four color theorem, to practicing mean, median, and mode, to even practicing dihybrid cross genotypes!

Now for, in my opinion, our most useful document for the midterm season: A study time calculator!

This document allows you to put in the amount you want to study each class over the day or week, and breaks down visually what that would look like.  

This allows you to make sure you’re taking enough time for breaks and sleep, and not overloading yourself. Feel free to customise the document to make it work better for you and your study style!

We hope you enjoyed this post, and that we could help you study! Let us know below if there’s anything else you’d want to see to support you during midterms and exams.

Maple allows to extract, manipulate, and optimize equations from a MapleSim model. Code can be generated from the equations in various programming languages. To verify the code, C code can be imported back into the original MapleSim model and compared to the model.

This verification step is not an everyday task, but it is advisable before the code is used elsewhere (e.g., in a controller). This post summarizes helpfull links and provides an additional example with equations that are too large to be efficiently verified by code review.

Comparison to a physical model is demonstrated here on an older version of MapleSim (~2015). In newer versions the import has changed (basics are described in Tutorial 6.6: Using the External C Code/DLL Custom Component App). An external C compiler must be set-up to make the import work.

The attached MapleSim model verifies against an optimized custom component. Instead of manually entering and modifying the code as described in the Tutorial 6.6, the model uses a Maple worksheet that programmatically generates C code from Maple equations and modifies the C code (sets C definitions and parameters) to be usable for MapleSim’s External C/Library Block App.

The Maple worksheet to generate and modify C code has been improved in many details with support from MaplePrime users for which I would like to express my thanks.

C_code_generation_of_optimised_code_for_MapleSim.mw

C_code_generation_of_optimised_code.msim

 

 

Have you heard the news yet? Maple Learn has had a major update! You may be wondering what this means, and what all the shiny new features are. Let’s go through them together.

First, as with many updates, we’ve improved performance with Maple Learn. Longer documents will load and perform faster, requiring less computing power for operations, and as a result your browser will be more responsive. Performance on Chromebooks is also improved.

Operations that previously would have needed to be refreshed now automatically calculate. Up until now, if you performed a menu operation on an expression and then changed the value of the expression, the result would turn orange to warn you that the result was no longer valid. You would then have to refresh manually. Now, this is no longer the case, the orange refresh button has been removed from Maple Learn, and results are never out of date.

The plot window, inline plots, and the context panel are all resizable now. This means that, for example, if you’re presenting using Maple Learn, you can enlarge the plot window to be the focus of the presentation, and shrink the context panel out of the way. Take a look at the difference, with our animation of it in action!

Sliders are also more flexible now! Bounds for sliders can be expressed in terms of variables or symbols like π. As well, you can now animate sliders, animating the graph. This allows for more interactivity in documents. See the old view on the left, and the new view on the right! Make sure to take a look at an example of the animated slider below the views as well. 

   

You can also now snap groups to a grid, allow them to automatically adjust their position as other groups adjust. This ensures better alignment of groups. It also allows you to easily rearrange elements of your documents.

Next, Maple Learn could handle 3D plots before, but now Maple Learn supports 3D parametric plots!

Finally, Maple Learn now has printing! This means you can print out your Maple Learn documents, with two options: to print just the canvas, or to print just the plot. This was requested by many users.

Multiple selection is also possible, allowing you to select multiple cells in a group by holding down the Ctrl/Command key while clicking and dragging.

That’s all for the updates in this version, but keep an eye out for our other updates! For more details, please take a look at our What’s New In Maple Learn page. We hope you enjoy our new features, and let us know if there are any more features you’d like to see in Maple Learn below.

Who else likes art?  I love art; doodling in my notebook between projects and classes is a great way to pass the time and keep my creativity sharp.  However, when I’m working in Maple Learn, I don’t need to get out my book; I can use the plot window as my canvas and get my drawing fix right then and there.

We’ve done a few blog posts on Maple Learn art, and we’re back at it again in even bigger and better ways.  Maple Learn’s recent update added some useful features that can be incorporated into art, including the ability to resize the plot window and animate using automatically-changing variables.

Even with all the previous posts, you may be thinking, “What’s all this?  How am I supposed to make art in a piece of math software?”  Well, there is a lot of beauty to mathematics.  Consider beautiful patterns and fractals, equations that produce surprisingly aesthetically interesting outputs, and the general use of mathematics to create technical art.  In Maple Learn, you don’t have to get that advanced (heck, unless you want to).  Art can be created by combining basic shapes and functions into any image you can imagine.  All of the images below were created in Maple Learn!

There are many ways you can harness artistic power in Maple Learn.  Here are the resources I recommend to get you started.

  1. I’ve recently made some YouTube videos (see the first one below) that provide a tutorial for Maple Learn art.  This series is less than 30 minutes in total, and covers - in three respective parts - the basics, some more advanced Learn techniques, and a full walkthrough of how I make my own art.
  2. Check out the Maple Learn document gallery art collection for some inspiration, the how-to documents for additional help, and the rest of the gallery to see even more Maple Learn in action!

Once you’re having fun and making art, consider submitting your art to the Maple Conference 2022 Maple Learn Art Showcase.  The due date for submission is October 14, 2022.  The Conference itself is on November 2-3, and is a free virtual event filled with presentations, discussions, and more.  Check it out!

 

I have polished up findings with custom components to share it here:

Optimized code generated with Maple’s codegen package cannot be used in the same way as it was possible with older versions of MapleSim’s Custom Component Template.

Intermediate variables `tx` (where x is an integer) of the optimized code are interpreted as physical parameters in the current template version and not as variables. This makes sense and is more consistent with MapleSim’s definition of variables and parameters, but leads to errors in MapleSim.

The attached model shows how optimized code can be generated for the current template and compares an older, still working (!) template with the new one.

The attached worksheet contains commands to programmatically generate optimized code for the current Custom Component Template.

CustomComponentTemplates_comparision.msim

Optimized_code_for_custom_component_template.mw


 

New display of arbitrary constants and functions

 

When using computer algebra, first we want results. Right. And textbook-like typesetting was not fully developed 20+ years ago. So, in the name of getting those results, people somehow got used to the idea of "give up textbook-quality computer algebra display". But computers keep evolving, and nowadays textbook typesetting is fully developed, so we have better typesetting in place. For example, consider this differential equation:

 

Download New_arbitrary_constants_and_functions.mw

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

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

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!

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

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!

 

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!

 

 

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

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

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