Teaching and learning about math, Maple and MapleSim

Carmichael's lambda(n) function (as it relates to Euler's Totient Function).....this is just one of 8 stages of animation. 


Here's the complete animation with supporting music by the mighty Stormtroopers Of Death....






Automatic handling of collision of tensor indices in products



The design of products of tensorial expressions that have contracted indices got enhanced. The idea: repeated indices in certain subexpressions are actually dummies. So suppose T[a, b] and B[b] are tensors, then in T[trace] = T[a, `~a`], a is just a dummy, therefore T[a, `~a`]*B[a] = T[b, `~b`]*B[a] is a well defined object. The new design automatically maps input like T[a, `~a`]*B[a] into T[b, `~b`]*B[a]. This significantly simplifies the manipulation of indices when working with products of tensorial expressions: each tensorial expression being multiplied has its repeated indices automatically transformed into different ones when they would collide with the free or repeated indices of the other expressions being multiplied.


This functionality is available within the Physics update distributed at the Maplesoft R&D Physics webpage (but for what you see under Preview that makes use of a new kernel feature of the Maple version under development).



with(Physics); Setup(spacetimeindices = lowercaselatin, quiet)

[spacetimeindices = lowercaselatin]


Define(T[a, b], B[b])

`Defined objects with tensor properties`


{B[b], Physics:-Dgamma[a], Physics:-Psigma[a], T[a, b], Physics:-d_[a], Physics:-g_[a, b], Physics:-KroneckerDelta[a, b], Physics:-LeviCivita[a, b, c, d]}


This shows the automatic handling of collision of indices

T[a, a]*B[a]

T[b, `~b`]*B[a]


T[a, a]^2

T[a, `~a`]*T[b, `~b`]



Preview only in the upcomming version under development


Consider now the case of three tensors

Define(A[a], C[a])

`Defined objects with tensor properties`


{A[a], B[b], C[a], Physics:-Dgamma[a], Physics:-Psigma[a], T[a, b], Physics:-d_[a], Physics:-g_[a, b], Physics:-KroneckerDelta[a, b], Physics:-LeviCivita[a, b, c, d]}





The product above has indeed the index a repeated more than once, therefore none of its occurrences got automatically transformed into contravariant in the output, and Check  detects the problem interrupting with an error  message


Error, (in Physics:-Check) wrong use of the summation rule for repeated indices: `a repeated 3 times`, in A[a]*B[a]*C[a]



However, it is now also possible to indicate, using parenthesis, that the product of two of these tensors actually form a subexpression, so that the following two tensorial expressions are well defined, and the colliding dummy is automatically replaced making that explicit









This change in design makes concretely simpler the use of indices in that it eliminates the need for manually replacing dummies. For example, consider the tensorial expression for the angular momentum in terms of the coordinates and momentum vectors, in 3 dimensions


Setup(coordinates = cartesian, dimension = 3, metric = euclidean, quiet)

[coordinatesystems = {X}, dimension = 3, metric = {(1, 1) = 1, (2, 2) = 1, (3, 3) = 1}]


Define L[j], p[k] respectively representing angular and linear momentum

Define(L[j], p[k])

`Defined objects with tensor properties`


{Physics:-Dgamma[a], L[j], Physics:-Psigma[a], Physics:-d_[a], Physics:-g_[a, b], p[k], Physics:-KroneckerDelta[a, b], Physics:-LeviCivita[a, b, c], Physics:-SpaceTimeVector[a](X)}


Introduce the tensorial expression for L[a]

L[a] = LeviCivita[a, b, c]*X[b]*p[c]

L[a] = Physics:-LeviCivita[a, b, c]*Physics:-SpaceTimeVector[b](X)*p[c]


The left-hand side has one free index, a, while the right-hand side has two dummy indices b and c

Check(L[a] = Physics[LeviCivita][a, b, c]*Physics[SpaceTimeVector][b](X)*p[c], all)

`The repeated indices per term are: `[{`...`}, {`...`}, `...`]*`; the free indices are: `*{`...`}


([{}], {a}) = ([{b, c}], {a})


If we want to compute`#mrow(msup(mfenced(mover(mi("L"),mo("→")),open = "‖",close = "‖"),mn("2")),mo("="),msubsup(mi("L"),mi("a"),mn("2")))`we can now take the square of (11) directly, and the dummy indices on the right-hand side are automatically handled, there is now no need to manually substitute the repeated indices to avoid their collision

(L[a] = Physics[LeviCivita][a, b, c]*Physics[SpaceTimeVector][b](X)*p[c])^2

L[a]^2 = Physics:-LeviCivita[a, b, c]*Physics:-SpaceTimeVector[b](X)*p[c]*Physics:-LeviCivita[a, d, e]*Physics:-SpaceTimeVector[d](X)*p[e]


The repeated indices on the right-hand side are now a, b, c, d, e

Check(L[a]^2 = Physics[LeviCivita][a, b, c]*Physics[SpaceTimeVector][b](X)*p[c]*Physics[LeviCivita][a, d, e]*Physics[SpaceTimeVector][d](X)*p[e], all)

`The repeated indices per term are: `[{`...`}, {`...`}, `...`]*`; the free indices are: `*{`...`}


([{a}], {}) = ([{a, b, c, d, e}], {})





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

--- Prolog.ue ---

The best things in life come free of charge.

Happiness, love, and wisdom of expertise are first few that hit my mind.

As a business economist, I keep my eyes keenly open to opportunities for growth; such as Maple 2017 training session.

It was a Saturday afternoon in Waterloo, ON, this chilly Feburary which was blessed by snowstorm warning.


--- Encountering with Maple ---

I was aware of Maple for many years back when my academic career began.

In fact, Maple was available in the lab computers at university. 

But I did not know what to do with it.

Nor did I use any mathematics softwares until recently, but I had this thought : one day I could learn.

The motivation for this `learn how to use it' did not occur to me for a long time (14 years!!).

Things changed this year when I enrolled to an Electrical Engineering program at Lassonde.

Mind you, I have already been using various types of languages and tools such as: Python, C, Java, OpenOfficeSuites, Stata, SAS, Latex just to mention a few.

These stuffs also run on multiple platforms which I am sure you have heard of if you're reading this post; Windows, OSX and Linux. And Maple supports all these major operating systems.


--- Why do I like Maple ---

During the first week of school, Dr. Smith would ask us to purchase and practice using MATLAB because it had a relatively easy learning curve for beginners like python and we were going to use it for labs.

Furthermore, students get a huge discount (i.e. $1500 to $50) for these softwares.

Then, the professor also added; "Maple is also a great tool to use, but we won't use it for this class".

ME: ' Why not ? '

The curiosity inside me gave in and I decided to try both!

After all, my laziness in taking derivatives by hand or the possibility of making mistake would disappear if I can verify results using software.

That's it...!

Being able to check correct answer was already worth more than $50.

I can not emphasize this point enough; 

For people in the industry being paid for their time, or students like me who got a busy schedule can not afford to waste any time. (i.e. need to minimize homework effort & frustration, while maximizing the educational attainment & final grades)

Right? Time is money.

Don't we all just want more spare time for things we care?

Googling through many ambiguous Yahoo Answers or online forums like Stackoverflow replies are often misleading and time consuming. 

I have spent years (estimated 3000+ hours) going through those wildly inaccurate webpages hoping for some clearly written information with sub-optimal outcome.

Diverting many hours of study time is not something a first year S.T.E.M. students can afford.


--- Maple Training ---

Now you know about my relationships with Maple; Let me describe how the training session went.

I will begin with the sad news first, =(

First of all, there was no coffee available when I arrived. It arrived only after lunch.

Although it was a free event aside other best things in life, this was only a material factor I didn't enjoy at the site. 

Still a large portion of Canadians start their work with a zolt of caffeine in my defence.

Secondly, there was a kind of assumption which expected attendee were familiar with software behavior.

A handful of people were having trouble opening example file, perhaps because of their browser setting or link to preferred software by OS.

Not being able to follow the tutorials as the presenter demonstrated various facets of software substantially diminished the  efficacy of training session for those who could not be on the same page.

These minor annoyances were the only drawbacks I experinced from the event.


Here comes the happy side, =)

1. The staffs were considerate enough to provide vegetarion options for inclusive lunch as well as answering all my curious, at times orthogonal questions regarding Maplesoft company.

2. Highly respectable professionals were presenting themselves; 

That is, Prof. Illias Kotsireas, Dr. Erik Postma and Dr. Jürgen Gerhard.

I can not appreciate enough of their contribution for the training in an eloquent and humble manners.

To put it other way, leading of the presentation was well structured and planned out.

In the beginning, Prof. Kotsireas presented `Introduction to Maple' which included terminology and basic behaviors of Maple (i.e. commands and features) with simple examples you can quickly digest. Furthermore, Maple has internal function to interface with Latex! No more typing hours of $$s and many frac{}{}, \delta_{} to publish. In order for me to study all this would have been two-weeks kind of commitment in which he summarized in a couple of hours time. Short-cut keys that are often used by his project was pretty interesting, which will improve work efficiency.

After a brief lunch, which was supplied more than enough for all, Dr. Erik Postma delivered a critical component of simluation. That is, `Random Number Generation'. Again, he showed us some software-related tricks such as `Text mode' vs. `Math mode'.  The default RNG embedded in the software allows reproducible results unless we set seed and randomize further. Main part of the presentation was regarding `Optimization of solution through simulation'. He iteratively improved efficiency of test model, which I will not go in depth here. However, visually and quantitatively showing the output was engaging the attendees and Maple has modularized this process (method available for all the users!!).

Finally, we got some coffee break that allowed to me to push through all the way to the end. I believe if we had some coffee earlier less attendees would have left.

The last part of the training was presented by Dr. Jürgen Gerhard. In this part, we were using various applications of Maple in solving different types of problems. We tackled combinatorics of Fibonacci sequence by formula manipulation. In this particular example he showed us how to optimize logic of a function that made a huge impact in processing time and memory usage. Followed by graph theory example, damped harmonic oscillator, 2 DOF chaotic system, optimization and lastly proof of orthocentre by coding. I will save the examples for you to enjoy in future sessions. 

The way they went through examples were super easy to follow. This can only be done with profound understanding of the subject and a lot of prior effort in preparing the presentation.

I appreciate much efforts put together by whom organized this event, allocating their own precious weekend time and allowing many to gain opportunity to learn directly from the person in the house.


--- Epilogue ---

My hope for Maple usage lies in enhancing education outcome for first year students, especially in the field of Science and Economics. This is a free opportunity for economic empowerment which is uncaptured.

Engineering students are already pretty good at problem solving, and will figure things out as I witnessed my colleagues have.

However, students of natural sciences and B.A. programs tend to skimp on utilizing tools due to lack of exposure.

Furthermore, I am supporting their development of SaaS, software as service, which delivers modules like gRPC does.

Also, I hope the optimization package from prior version written by Dr. Postma will become available to public sometime.

Here's a BIG thank you to staffs once again, and forgive me for any grammatical errors from rushed writing. I tried to incorporate as much observation as possible gathered from the event.

To contact me, my email is hyonwoo.kee (at);


Minimize the number of tensor components according to its symmetries
(and relabel, redefine or count the number of independent tensor components)



The nice development described below is work in collaboration with Pascal Szriftgiser from Laboratoire PhLAM, Université Lille 1, France, used in the Mapleprimes post Magnetic traps in cold-atom physics


A new keyword in Define  and Setup : minimizetensorcomponents, allows for automatically minimizing the number of tensor components taking into account the tensor symmetries. For example, if a tensor with two indices in a 4D spacetime is defined as antisymmetric using Define with this new keyword, the number of different tensor components will be exactly 6, and the elements of the diagonal are automatically set equal to 0. After setting this keyword to true with Setup , all subsequent definitions of tensors automatically minimize the number of components while using this keyword with Define  makes this minimization only happen with the tensors being defined in the call to Define .


Related to this new functionality, 4 new Library routines were added: MinimizeTensorComponents, NumberOfIndependentTensorComponents, RelabelTensorComponents and RedefineTensorComponents



restart; with(Physics)


Define an antisymmetric tensor with two indices

Define(F[mu, nu], antisymmetric)

`Defined objects with tensor properties`


{Physics:-Dgamma[mu], F[mu, nu], Physics:-Psigma[mu], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-KroneckerDelta[mu, nu], Physics:-LeviCivita[alpha, beta, mu, nu]}


Although the system knows that F[mu, nu] is antisymmetric, you need to use Simplify to apply the (anti)symmetry

F[mu, nu]+F[nu, mu]

F[mu, nu]+F[nu, mu]



Simplify(F[mu, nu]+F[nu, mu])



so by default the components of F[mu, nu] do not automatically reflect the (anti)symmetry; likewise

F[1, 2]+F[2, 1]

F[1, 2]+F[2, 1]


Simplify(F[1, 2]+F[2, 1])



and computing the array form of F[mu, nu]we do not see the elements of the diagonal equal to zero nor the lower-left triangle equal to the upper-right triangle but for a different sign:

TensorArray(F[mu, nu])

Matrix(%id = 18446744078270093062)



On the other hand, this new functionality, here called minimizetensorcomponents, makes the symmetries of the tensor be explicitly reflected in its components.


There are three ways to use it. First, one can minimize the number of tensor components of a tensor previously defined. For example



Matrix(%id = 18446744078270064630)


After this, both (1.2) and (1.3) are automatically equal to 0 without having to use Simplify

F[mu, nu]+F[nu, mu]






And the output of TensorArray  in (1.6) becomes equal to (1.7).


NOTE: in addition, after using minimizetensorcomponents in the definition of a tensor, say F, all the keywords implemented for Physics tensors are available for F:



F[mu, nu] = Matrix(%id = 18446744078247910206)






F[mu, nu] = {(1, 2) = F[1, 2], (1, 3) = F[1, 3], (1, 4) = F[1, 4], (2, 1) = -F[1, 2], (2, 3) = F[2, 3], (2, 4) = F[2, 4], (3, 1) = -F[1, 3], (3, 2) = -F[2, 3], (3, 4) = F[3, 4], (4, 1) = -F[1, 4], (4, 2) = -F[2, 4], (4, 3) = -F[3, 4]}



F[`~1`, mu] = Vector[row](%id = 18446744078247885990)


Alternatively, one can define a tensor, specifying that the symmetries should be taken into account to minimize the number of its components passing the keyword minimizetensorcomponents to Define .




Define a tensor with the symmetries of the Riemann  tensor, that is, a tensor of 4 indices that is symmetric with respect to interchanging the positions of the 1st and 2nd pair of indices and antisymmetric with respect to interchanging the position of its 1st and 2nd indices, or 3rd and 4th indices, and define it minimizing the number of tensor components


Define(R[alpha, beta, mu, nu], symmetric = {[[1, 2], [3, 4]]}, antisymmetric = {[1, 2], [3, 4]}, minimizetensorcomponents)

`Defined objects with tensor properties`


{Physics:-Dgamma[mu], F[mu, nu], Physics:-Psigma[mu], R[mu, nu, alpha, beta], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-KroneckerDelta[mu, nu], Physics:-LeviCivita[alpha, beta, mu, nu]}


We now have

R[1, 2, 3, 4]+R[2, 1, 3, 4]



R[alpha, beta, mu, nu]-R[mu, nu, alpha, beta]



One can always retrieve the symmetry properties in the abstract notation used by the Define command using the new Library:-GetTensorSymmetryProperties, its output is ordered, first the symmetric then the antisymmetric properties



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


After making the symmetries explicit (and also before that), it is frequently useful to know the number of independent components of a given tensor. For this purpose you can use the new Library:-NumberOfIndependentTensorComponents





and besides taking into account the symmetries, in the case of the Riemann  tensor, after taking into account the first Bianchi identity this number of components is further reduced to 20.


A third way of using the new minimizetensorcomponents functionality is using Setup , so that, automatically, every subsequent definition of tensors with symmetries is performed minimizing the number of its components using the indicated symmetries



Setup(minimizetensorcomponents = true)

[minimizetensorcomponents = true]


So from hereafter you can define tensors taking into account their symmetries explicitly and without having to include the keyword minimizetensorcomponents at each definition


Define(C[alpha, beta], antisymmetric)

`Defined objects with tensor properties`


{C[mu, nu], Physics:-Dgamma[mu], F[mu, nu], Physics:-Psigma[mu], R[mu, nu, alpha, beta], Physics:-d_[mu], Physics:-g_[mu, nu], Physics:-KroneckerDelta[mu, nu], Physics:-LeviCivita[alpha, beta, mu, nu]}




C[mu, nu] = Matrix(%id = 18446744078408747598)


Two new related functionalities are provided via Library:-RelabelTensorComponents and Library:-RedefineTensorComponent, the first one to have the number of tensor components directly reflected in the names of the components, the second one to redefine only one of these components


Matrix(%id = 18446744078408729774)



Suppose now we want to make one of these components equal to 1, say C__2

Library:-RedefineTensorComponent(C[1, 2] = 1)

C[mu, nu] = Matrix(%id = 18446744078270104390)


This nice development is work in collaboration with Pascal Szriftgiser from Laboratoire PhLAM, UMR CNRS 8523, Université Lille 1, F-59655, France.





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



I study mainly subjects that fall under umbrella of number theory, but i have specified a little further in the worksheet. This is really a request for assistance, because in as much as i have met so many brilliant people online via social media etc,  I would always love to meet more, and especially ones who are more experienced in this field. 


Basically i am too cheap and old to think about going to a good university, so I am trying to get free advice from the people who have probably completed doctorates in the relevant field. Got to be honest I say.


Anyway my contact email is at the top of the attached worksheet.


First thing that stood out to me about the distributions produced in this worksheet is how sparse the number of points is for N=17 relative to all the other values of N.


Edit: Another example worksheet added.

Dear all , I' would like to join a group to produce quantum information tools in Maple



As the title says, a lesson on functions:  eg the -> operator, f(2), eval, evalf etc 

Using the learning sequence as an alternative to learn problems related to "balance of a body" is shown in this video; thanks to the kindness that Maple offers us in its fundamental programming syntax.

Lenin Araujo

Ambassador Of Maple



On the example of a manipulator with three degrees of freedom.
A mathematical model is created that takes into account degrees of freedom of the manipulator and the trajectory of the movement from the initial point to the final one (in the figure, the ends of the red curve). In the text of the program, these are the equations fi, i = 1..5.
Obviously, the straight line could be the simplest trajectory, but we will consider a slightly different variant. The solution of the system of equations is the coordinates of the points of the manipulator (x1, x2, x3) and (x4, x5, x6) in all trajectory. After that, knowing the lengths of the links and the coordinates of the points at each moment of time, any angles of the manipulator are calculated. The same selected trajectory is reproduced from these angles. The possible angles are displayed by black color.
All the work on creating a mathematical model and calculating the angles can be done without the manipulator itself, is sufficient to have only the instruction with technical characteristics.
To display some angles, the procedure created by vv is used.

This post is devoted to the rigorous proof of Miquel's five circles theorem, which I learned about from this question. The proof is essentially very simple and takes only 15 lines of code. The figure below, in which all the labels coincide with the corresponding names in the code, illustrates the basic ideas of the code. First, we symbolically define common points of intersection of blue circles with a red unit circle  (these parameters  s1 .. s5  are the polar coordinates of these points). All other parameters of this configuration can be expressed through them. Then we find the centers  M  and  N  of two circles. Then we find the coordinates of the point  K  from the condition that  CK  is perpendicular to  MN . Then we find the point  and using the result obtained, we easily find the coordinates  of all the points  A1 .. A5. Then we find the coordinates of the point   P  as the point of intersection of the lines  A1A2  and  A3A4 . Finally, we verify that the point  P  lies on a circle with center at the point  N , which completes the proof.



Below - the code of the proof. Note that the code does not use any special (in particular geometric) packages, only commands from the Maple kernel. I usually try any geometric problems to solve in this style, it is more reliable,  and often shorter.

t1:=s1/2+s2/2: t2:=s2/2+s3/2:
M:=[cos(t1),sin(t1)]: N:=[cos(t2),sin(t2)]:
C:=[cos(s2),sin(s2)]: K:=(1-t)*~M+t*~N:
CK:=K-C: MN:=M-N:
t0:=simplify(solve(CK[1]*MN[1]+CK[2]*MN[2]=0, t)):
s0:=s5-2*Pi: s6:=s1+2*Pi:
assign(seq(A||i=eval(E,[s2=s||i,s1=s||(i-1),s3=s||(i+1)]), i=1..5)):
is(eval(Circle, P)=0);  
# The final result


It may seem that this proof is easy to repeat manually. But this is not so. Maple brilliantly coped with very cumbersome trigonometric transformations. Look at the coordinates of point  , expressed through the initial parameters  s1 .. s5 :

simplify(eval([x,y], P));  # The coordinates of the point  P


A few days ago, I drew attention to the question in which OP talked about the generation of triangles in a plane, for which the lengths of all sides, the area and radius of the inscribed circle are integers. In addition, all vertices must have different integer coordinates (6 different integers), the lengths of all sides are different and the triangles should not be rectangular. I prepared the answer to this question, but the question disappeared somewhere, so I designed my answer as a separate post.

The triangles in the plane, for which the lengths of all sides and the area  are integers, are called as Heronian triangles. See this very interesting article in the wiki about such triangles

The procedure finds all triangles (with the fulfillment of all conditions above), for which the lengths of the two sides are in the range  N1 .. N2 . The left side of the range is an optional parameter (by default  N1=5). It is not recommended to take the length of the range more than 100, otherwise the operating time of the procedure will greatly increase. The procedure returns the list in which each triangle is represented by a list of  [list of coordinates of the vertices, area, radius of the inscribed circle, list of lengths of the sides]. Without loss of generality, one vertex coincides with the origin (obviously, by a shift it is easy to place it at any point). 

The procedure works as follows: one vertex at the origin, then the other two must lie on circles with integer and different radii  x^2+y^2=r^2. Using  isolve  command, we find all integer points on these circles, and then in the for loops we select the necessary triangles.



local k, r, S, L, Ch, Dist, IsOnline, c, P, p, A, B, C, a, b, s, ABC, cc, s1, T ;
uses combinat, geometry;
if N2<N1 then error "Should be N2>=N1" fi;
if N2<34 then return [] fi;
for r from max(N1,5) to N2 do
if nops(S)>4 then k:=k+1; L[k]:=select(s->s[1]<>0 and s[2]<>0,map(t->rhs~(convert(t,list)), S)); fi;
L:=convert(L, list):
if type(L[1],symbol) then return [] fi;

Ch:=combinat:-choose([$1..nops(L)], 2):
IsOnline:=(A::list,B::list)->`if`(A[1]*B[2]-A[2]*B[1]=0, true, false);
for c in Ch do
for A in L[c[1]] do
for B in L[c[2]] do
if not IsOnline(A,B) and nops({A[],B[]})=4 then if type(Dist(A,B),posint) then
 k:=k+1; P[k]:=[A,B] fi; fi;
od: od: od:
P:=convert(P, list):
if type(P[1],symbol) then return [] fi;

for p in P do
point('A',0,0), point('B',p[1]), point('C',p[2]);
a:=simplify(distance('A','B')); b:=simplify(distance('A','C')); c:=simplify(distance('B','C'));
s:=sort([a,b,c]); s1:={a,b,c};
if type(r,integer) and s[3]^2<>s[1]^2+s[2]^2 and nops(s1)=3 then k:=k+1; T[k]:=[[[0,0],p[]],area(ABC),r, [a,b,c]] fi;
if type(T[1],symbol) then return [] fi;
end proc:

Examples of use of the procedure  HeronianTriangles

T:=HeronianTriangles(100): # All the Geronian triangles, whose lengths of two sides do not exceed 100



Tp:=select(p->p[1,2,1]>0 and p[1,2,2]>0 and p[1,3,1]>0 and p[1,3,2]>0, T);

[[[[0, 0], [16, 30], [28, 21]], 252, 6, [34, 35, 15]], [[[0, 0], [30, 16], [21, 28]], 252, 6, [34, 35, 15]], [[[0, 0], [21, 28], [15, 36]], 168, 4, [35, 39, 10]], [[[0, 0], [28, 21], [36, 15]], 168, 4, [35, 39, 10]], [[[0, 0], [27, 36], [13, 84]], 900, 10, [45, 85, 50]], [[[0, 0], [36, 27], [84, 13]], 900, 10, [45, 85, 50]], [[[0, 0], [33, 44], [48, 36]], 462, 7, [55, 60, 17]], [[[0, 0], [44, 33], [36, 48]], 462, 7, [55, 60, 17]], [[[0, 0], [33, 44], [96, 28]], 1650, 15, [55, 100, 65]], [[[0, 0], [44, 33], [28, 96]], 1650, 15, [55, 100, 65]], [[[0, 0], [16, 63], [72, 21]], 2100, 20, [65, 75, 70]], [[[0, 0], [63, 16], [21, 72]], 2100, 20, [65, 75, 70]], [[[0, 0], [39, 52], [18, 80]], 1092, 12, [65, 82, 35]], [[[0, 0], [52, 39], [80, 18]], 1092, 12, [65, 82, 35]], [[[0, 0], [32, 60], [56, 42]], 1008, 12, [68, 70, 30]], [[[0, 0], [60, 32], [42, 56]], 1008, 12, [68, 70, 30]], [[[0, 0], [42, 56], [30, 72]], 672, 8, [70, 78, 20]], [[[0, 0], [56, 42], [72, 30]], 672, 8, [70, 78, 20]]]


point(A,Tr[1]), point(B,Tr[2]), point(C,Tr[3]):
simplify(distance(A,B)), simplify(distance(A,C)), simplify(distance(B,C));
local O:
incircle(c,ABC, centername=O):
draw([A,B,C, ABC, c(color=blue)], color=red, thickness=2, symbol=solidcircle, tickmarks = [spacing(1)$2], gridlines, scaling=constrained, view=[0..31,0..33], size=[800,550], printtext=true, font=[times, 18], axesfont=[times, 10]);

[[2, 1], [18, 31], [30, 22]]


34, 35, 15



Examples of triangles with longer sides

T:=HeronianTriangles(1000,980):  # All the Geronian triangles, whose lengths of two sides lie in the range  980..1000



Tp:=select(p->p[1,2,1]>0 and p[1,2,2]>0 and p[1,3,1]>0 and p[1,3,2]>0, T);  # Triangles lying in the first quarter x>0, y>0

[[[[0, 0], [540, 819], [680, 714]], 85680, 80, [981, 986, 175]], [[[0, 0], [819, 540], [714, 680]], 85680, 80, [981, 986, 175]], [[[0, 0], [216, 960], [600, 800]], 201600, 168, [984, 1000, 416]], [[[0, 0], [960, 216], [800, 600]], 201600, 168, [984, 1000, 416]], [[[0, 0], [380, 912], [324, 945]], 31806, 31, [988, 999, 65]], [[[0, 0], [912, 380], [945, 324]], 31806, 31, [988, 999, 65]], [[[0, 0], [594, 792], [945, 324]], 277992, 216, [990, 999, 585]], [[[0, 0], [792, 594], [324, 945]], 277992, 216, [990, 999, 585]]]








The Joint Mathematics Meetings are taking place this week (January 10 – 13) in San Diego, California, U.S.A. This will be the 101th annual winter meeting of the Mathematical Association of America (MAA) and the 124nd annual meeting of the American Mathematical Society (AMS).

Maplesoft will be exhibiting at booth #505 as well as in the networking area. Please stop by our booth or the networking area to chat with me and other members of the Maplesoft team, as well as to pick up some free Maplesoft swag or win some prizes.

There are also several interesting Maple-related talks and events happening this week - I would definitely not miss the talk by our own Paulina Chin on grading sketch graphs.


Using Symbol-Crunching to find ALL Sucker's Bets (with given deck sizes). 

AMS Special Session on Applied and Computational Combinatorics, II 
Wednesday January 10, 2018, 2:15 p.m.-2:45 p.m.

Shalosh B. Ekhad, Rutgers University, New Brunswick 
Doron Zeilberger*, Rutgers University, New Brunswick 

Collaborative Research: Maplets for Calculus. 

MAA Poster Session: Projects Supported by the NSF Division of Undergraduate Education 
Thursday January 11, 2018, 2:00 p.m.-4:00 p.m.

Philip B. Yasskin*, Texas A&M University 
Douglas B. Meade, University of South Carolina 
Matthew Barry, Texas A&M Engineering Extension Service 
Andrew Crenwelge, Texas A&M University 
Joseph Martinson, Texas A&M University 
Matthew Weihing, Texas A&M University


Automated Grading of Sketched Graphs in Introductory Calculus Courses. 

AMS Special Session on Visualization in Mathematics: Perspectives of Mathematicians and Mathematics Educators, I 

Friday January 12, 2018, 9:00 a.m.

Dr. Paulina Chin*, Maplesoft 


Semantic Preserving Bijective Mappings of Mathematical Expressions between LaTeX and Computer Algebra Systems.

AMS Special Session on Mathematical Information in the Digital Age of Science, III 
Friday January 12, 2018, 9:00 a.m.-9:20 a.m.

Howard S. Cohl*, NIST 


Interactive Animations in MYMathApps Calculus. 

MAA General Contributed Paper Session on Mathematics and Technology 
Saturday January 13, 2018, 11:30 a.m.-11:40 a.m.

Philip B. Yasskin*, Texas A&M University 
Andrew Crenwelge, Texas A&M University 
Joseph Martinsen, Texas A&M University 
Matthew Weihing, Texas A&M University 
Matthew Barry, Texas A&M Engineering Experiment Station 


Applying Maple Technology in Calculus Teaching To Create Artwork. 

MAA General Contributed Paper Session on Teaching and Learning Calculus, II 
Saturday January 13, 2018, 2:15 p.m.

Lina Wu*, Borough of Manhattan Community College-The City University of New York


If you are attending the Joint Math meetings this week and plan on presenting anything on Maple, please feel free to let me know and I'll update this list accordingly.

See you in San Diego!


Maple Product Manager

Implementation of Maple apps for the creation of mathematical exercises in

In this research work has allowed to show the implementation of applications developed in the Maple software for the creation of mathematical exercises given the different levels of education whether basic or higher.
For the majority of teachers in this area, it seems very difficult to implement apps in Maple; that is why we show the creation of exercises easily and permanently. The purpose is to get teachers from our institutions to use applications ready to be evaluated in the classroom. The results of these apps (applications with components made in Maple) are supported on mobile devices such as tablets and / or laptops and taken to the cloud to be executed online from any computer. The generation of patterns is a very important alternative leaving aside random numbers, which would allow us to lose results
onscreen. With this; Our teachers in schools or universities would evaluate their students in parallel on the blackboard without losing the results of any student and thus achieve the competencies proposed in the learning sessions.
In these apps would be the algorithms for future research updates and integrated with systems in content management. Therefore what we show here is extremely important for the evaluation on the blackboard in bulk to students without losing any scientific criteria.


Lenin Araujo Castillo

Ambasador of Maple


It passed through my mind it would be interesting to collect the links to the most relevant Mapleprimes posts about Quantum Mechanics using the Physics package of the last couple of years, to have them all accessible from one place. These posts give an idea of what kind of computation is already doable in quantum mechanics, how close is the worksheet input to what we write with paper and pencil, and how close is the typesetting of the output to what we see in textbooks.

At the end of each page linked below, you will see another link to download the corresponding worksheet, that you can open using Maple (say the current version or the version 1 or 2 years ago).

This other set of three consecutive posts develops one problem split into three parts:

This other link is interesting as a quick and compact entry point to the use of the Physics package:

There is an equivalent set of Mapleprimes posts illustrating the Physics package tackling problems in General Relativity, collecting them is for one other time.

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

December 2017: This is, perhaps, one of the most complicated computations done in this area using the Physics package. To the best of my knowledge never before performed on a computer algebra worksheet. It is exciting to present a computation like this one. At the end the corresponding worksheet is linked so that it can be downloaded and the sections be opened, the computation be reproduced. There is also a link to a pdf with everything open.  Special thanks to Pascal Szriftgiser for bringing this problem. To reproduce the computations below, please update the Physics library with the one distributed from the Maplesoft R&D Physics webpage.

June 17, 2020: updated taking advantage of new features of Maple 2020.1 and Physics Updates v.705. Submitted to

January 25, 2021: updated in the arXiv and submitted for publication in Computer Physics Communications



Quantum Runge-Lenz Vector and the Hydrogen Atom,

the hidden SO(4) symmetry using Computer Algebra


Pascal Szriftgiser1 and Edgardo S. Cheb-Terrab2 

(1) University of Lille, CNRS, UMR 8523 - PhLAM - Physique des Lasers, Atomes et Molécules, F-59000 Lille, France

(2) Maplesoft





Pauli first noticed the hidden SO(4) symmetry for the Hydrogen atom in the early stages of quantum mechanics [1]. Departing from that symmetry, one can recover the spectrum of a spinless hydrogen atom and the degeneracy of its states without explicitly solving Schrödinger's equation [2]. In this paper, we derive that SO(4) symmetry and spectrum using a computer algebra system (CAS). While this problem is well known [3, 4], its solution involves several steps of manipulating expressions with tensorial quantum operators, simplifying them by taking into account a combination of commutator rules and Einstein's sum rule for repeated indices. Therefore, it is an excellent model to test the current status of CAS concerning this kind of quantum-and-tensor-algebra computations. Generally speaking, when capable, CAS can significantly help with manipulations that, like non-commutative tensor calculus subject to algebra rules, are tedious, time-consuming and error-prone. The presentation also shows a pattern of computer algebra operations that can be useful for systematically tackling more complicated symbolic problems of this kind.




The primary purpose of this work is to derive, step-by-step, the SO(4) symmetry of the Hydrogen atom and its spectrum using a computer algebra system (CAS). To the best of our knowledge, such a derivation using symbolic computation has not been shown before. Part of the goal was also to see whether this computation can be performed entering only the main definition formulas, followed by only simplification commands, and without using previous knowledge of the result. The intricacy of this problem is in the symbolic manipulation and simplification of expressions involving noncommutative quantum tensor operators. The simplifications need to take into account commutator rules, symmetries under permutation of indices of tensorial subexpressions, and use Einstein's sum rule for repeated indices.

We performed the derivation using the Maple 2020 system with the Maplesoft Physics Updates v.705. Generally speaking, the default computational domain of CAS doesn't include tensors, noncommutative operators nor related simplifications. On the other hand, the Maple system is distributed with a Physics package that extends that default domain to include those objects and related operations. Physics includes a Simplify command that takes into account custom algebra rules and the sum rule for repeated indices, and uses tensor-simplification algorithms [5] extended to the noncommutative domain.


A note about notation: when working with a CAS, besides the expectation of achieving a correct result for a complicated symbolic calculation, readability is also an issue. It is desired that one be able to enter the definition formulas and computational steps to be performed (the input, preceded by a prompt >, displayed in black) in a way that resembles as closely as possible their paper and pencil representation, and that the results (the output, computed by Maple, displayed in blue) use textbook mathematical-physics notation. The Physics package implements such dedicated typesetting. In what follows, within text and in the output, noncommutative objects are displayed using a different color, e.g. H, vectors and tensor indices are displayed the standard way, as in `#mover(mi("L",mathcolor = "olive"),mo("&rarr;"))`, and L[q], and commutators are displayed with a minus subscript, e.g. "[H,L[q]][-]". Although the Maple system allows for providing dedicated typesetting also for the input, we preferred to keep visible the Maple input syntax, allowing for comparison with paper and pencil notation. We collected the names of the commands used and a one line description for them in an Appendix at the end. Maple also implements the concept of inert representations of computations, which are activated only when desired. We use this feature in several places. Inert computations are entered by preceding the command with % and are displayed in grey. Finally, as is usual in CAS, every output has an equation label, which we use throughout the presentation to refer to previous intermediate results.


In Sec.1, we recall the standard formulation of the problem and present the computational goal, which is the derivation of the formulas representing the SO(4) symmetry and related spectrum.


In Sec.2, we set tensorial non-commutative operators representing position and linear and angular momentum, respectively X[a], p[a] and L[a], their commutation rules used as departure point, and the form of the quantum Hamiltonian H. We also derive a few related identities used in the sections that follow.


In Sec.3, we derive the conservation of both angular momentum and the Runge-Lenz quantum operator, respectively "[H,L[q]][-]=0" and "[H,Z[k]][-]=0". Taking advantage of the differentialoperators functionality in the Physics package, we perform the derivation exploring two equivalent approaches; first using only a symbolic tensor representation p[j] of the momentum operator, then using an explicit differential operator representation for it in configuration space, p[j] = -i*`&hbar;`*`&PartialD;`[j].  With the first approach, expressions are simplified only using the departing commutation rules and Einstein's sum rule for repeated indices. Using the second approach, the problem is additionally transformed into one where the differentiation operators are applied explicitly to a test function G(X). Presenting both approaches is of potential interest as it offers two partly independent methods for performing the same computation, which is helpful to provide confidence on in the results when unknown, a relevant issue when using computer algebra.


In Sec. 4, we derive %Commutator(L[m], Z[n]) = I*`&hbar;`*`&epsilon;`[m, n, u]*Z[u] and show that the classical relation between angular momentum and the Runge-Lenz vectors,  "L *"`#mover(mi("Z"),mo("&rarr;"))` = 0, due to the orbital momentum being perpendicular to the elliptic plane of motion while the Runge-Lenz vector lies in that plane, still holds in quantum mechanics, where the components of these quantum vector operators do not commute but "L *"`#mover(mi("Z",mathcolor = "olive"),mo("&rarr;"))` = "(Z) *"`#mover(mi("L",mathcolor = "olive"),mo("&rarr;"))` = 0.


In Sec. 5, we derive "[Z[a],Z[b]][-]=-(2 i `&hbar;` `&epsilon;`[a,b,c] (H L[c]))/`m__e`" using the two alternative approaches described for Sec.3.

In Sec. 6, we derive the well-known formula for the square of the Runge-Lenz vector, Z[k]^2 = 2*H*(`&hbar;`^2+L[a]^2)/m__e+kappa^2.


Finally, in Sec. 7, we use the SO(4) algebra derived in the previous sections to obtain the spectrum of the Hydrogen atom. Following the literature, this approach is limited to the bound states for which the energy is negative.


Some concluding remarks are presented at the end, and input syntax details are summarized in an Appendix.


1. The hidden SO(4) symmetry of the Hydrogen atom



Let's consider the Hydrogen atom and its Hamiltonian

H = LinearAlgebra[Norm](`#mover(mi("p"),mo("&rarr;"))`)^2/(2*m__e)-kappa/r,


where `#mover(mi("p"),mo("&rarr;"))`is the electron momentum, m__e its mass, κ a real positive constant, r = `&equiv;`(LinearAlgebra[Norm](`#mover(mi("r"),mo("&rarr;"))`), sqrt(X[a]^2)) the distance of the electron from the proton located at the origin, and X[a] is its tensorial representation with components ["x, y,z]". We assume that the proton's mass is infinite. The electron and nucleus spin are not taken into account. Classically, from the potential -kappa/r, one can derive a central force `#mover(mi("F"),mo("&rarr;"))` = -kappa*`#mover(mi("r"),mo("&and;"))`/r^2 that drives the electron's motion. Introducing the angular momentum


`#mover(mi("L"),mo("&rarr;"))` = `&x`(`#mover(mi("r"),mo("&rarr;"))`, `#mover(mi("p"),mo("&rarr;"))`),


one can further define the Runge-Lenz vector `#mover(mi("Z"),mo("&rarr;"))`


"Z=1/(`m__e`) (L)*(p)+kappa ( r)/r."


It is well known that `#mover(mi("Z"),mo("&rarr;"))` is a constant of the motion, i.e. diff(`#mover(mi("Z"),mo("&rarr;"))`(t), t) = 0. Switching to Quantum Mechanics, this condition reads


%Commutator(H, Z_) = 0.


where, for hermiticity purpose, the expression of `#mover(mi("Z",mathcolor = "olive"),mo("&rarr;"))` must be symmetrized


`#mover(mi("Z",mathcolor = "olive"),mo("&rarr;"))` = (`&x`(`#mover(mi("L",mathcolor = "olive"),mo("&rarr;"))`, `#mover(mi("p",mathcolor = "olive"),mo("&rarr;"))`)-`&x`(`#mover(mi("p",mathcolor = "olive"),mo("&rarr;"))`, `#mover(mi("L",mathcolor = "olive"),mo("&rarr;"))`))/(2*m__e)+kappa*`#mover(mi("r",mathcolor = "olive"),mo("&rarr;"))`/r.


In what follows, departing from the Hamiltonian H, the basic commutation rules between position`#mover(mi("r",mathcolor = "olive"),mo("&rarr;"))`, momentum `#mover(mi("p",mathcolor = "olive"),mo("&rarr;"))` and angular momentum `#mover(mi("L",mathcolor = "olive"),mo("&rarr;"))` in tensor notation, we derive the following commutation rules between the quantum Hamiltonian, angular momentum and Runge-Lenz vector `#mover(mi("Z",mathcolor = "olive"),mo("&rarr;"))`









" [L[m],Z[n]][-]"


I*`&hbar;`*`&epsilon;`[m, n, o]*Z[o]

" [Z[m],Z[n]][-]"


-(2*(I*`&hbar;`/m__e))*H*`&epsilon;`[m, n, o]*L[o]



Since H commutes with both `#mover(mi("L",mathcolor = "olive"),mo("&rarr;"))`NULL and `#mover(mi("Z",mathcolor = "olive"),mo("&rarr;"))`, defining


"`M__n`=sqrt(-(`m__e`)/(2 H)) `Z__n`,"

these commutation rules can be rewritten as




I*`&hbar;`*`&epsilon;`[m, n, o]*L[o]

" [L[m],M[n]][-]"


I*`&hbar;`*`&epsilon;`[m, n, o]*M[o]



I*`&hbar;`*`&epsilon;`[m, n, o]*L[o]




This set constitutes the Lie algebra of the SO(4) group.



2. Setting the problem, commutation rules and useful identities


3. Commutation rules between the Hamiltonian and each of the angular momentum and Runge-Lenz tensors


4. Commutation rules between the angular momentum L[q]and the Runge-Lenz Z[k]tensors


5.  Commutation rules between the components of the Runge-Lenz tensor


6. The square of the norm of the Runge-Lenz vector


7. The atomic hydrogen spectrum





In this presentation, we derived, step-by-step, the SO(4) symmetry of the Hydrogen atom and its spectrum using the symbolic computer algebra Maple system. The derivation was performed without departing from the results, entering only the main definition formulas in eqs. (1), (2) and (5), followed by using a few simplification commands - mainly Simplify, SortProducts and SubstituteTensor - and a handful of Maple basic commands, subs, lhs, rhs and isolate. The computational path that was used to get the results of sections 2 to 7 is not unique. Instead of searching for the shortest path, we prioritized clarity and illustration of the techniques that can be used to crack problems like this one.

This problem is mainly about simplifying expressions using two different techniques. First, expressions with noncommutative operands in products need reduction with respect to the commutator algebra rules that have been set. Second, products of tensorial operators require simplification using the sum rule for repeated indices and the symmetries of tensorial subexpressions. Those techniques, which are part of the Maple Physics simplifier, together with the SortProducts and SubstituteTensor commands for sorting the operands in products to apply tensorial identities, sufficed. The derivations were performed in a reasonably small number of steps.

Two different computational strategies - with and without differential operators - were used in sections 3 and 5, showing an approach for verifying results, a relevant issue in general when performing complicated algebraic manipulations. The Maple Physics ability to handle differential operators as noncommutative operands in products (as frequently done in paper and pencil computations) facilitates readability and ease in entering the computations. The complexity of those operations is then handled by one Physics:-Library command, ApplyProductsOfDifferentialOperators (see eqs. (47) and (83)).

Besides the Maple Physics ability to handle noncommutative tensor operators and simplify such operators using commutator algebra rules, it is interesting to note: a) the ability of the system to factorize expressions involving products of noncommutative operands (see eqs. (90) and (108)) and b) the extension of the algorithms for simplifying tensorial expressions [5] to the noncommutativity domain, used throughout this presentation.

It is also worth mentioning how equation labels can reduce the whole computation to entering the main definitions, followed by applying a few commands to equation labels. That approach helps to reduce the chance of typographical errors to a very strict minimum. Likewise, the fact that commands and equations distribute over each other allows cumbersome manipulations to be performed in simple ways, as done, for instance, in eqs. (8), (9) and (13).

Finally, it was significantly helpful for us to have the typesetting of results using standard mathematical physics notation, as shown in the presentation above.





In this presentation, the input lines are preceded by a prompt > and the commands used are of three kinds: some basic Maple manipulation commands, the main Physics package commands to set things and simplify expressions, and two commands of the Physics:-Library to perform specialized, convenient, operations in expressions.


The basic Maple commands used



interface is used once at the beginning to set the letter used to represent the imaginary unit (default is I but we used i).


isolate is used in several places to isolate a variable in an expression, for example isolating x in a*x+b = 0 results in x = -b/a


lhs and rhs respectively get the left-hand side Aand right-hand side Bof an equation A = B


subs substitutes the left-hand side of an equation by the righ-hand side in a given target, for example subs(A = B, A+C) results in B+C


@ is used to compose commands. So(`@`(A, B))(x) is the same as A(B(x)). This command is useful to express an abstract combo of manipulations, for example as in (108) ≡ lhs = `@`(Factor, rhs).


The Physics commands used



Setup is used to set algebra rules as well as the dimension of space, type of metric, and conventions as the kind of letter used to represent indices.


Commutator computes the commutator between two objects using the algebra rules set using Setup. If no rules are known to the system, it outputs a representation for the commutator that the system understands.


CompactDisplay is used to avoid redundant display of the functionality of a function.


d_[n] represents the `&PartialD;`[n] tensorial differential operator.


Define is used to define tensors, with or without specifying its components.


Dagger  computes the Hermitian transpose of an expression.


Normal, Expand, Factor respectively normalizes, expands and factorizes expressions that involve products of noncommutative operands.


Simplify performs simplification of tensorial expressions involving products of noncommutative factors taking into account Einstein's sum rule for repeated indices, symmetries of the indices of tensorial subexpressions and custom commutator algebra rules.


SortProducts uses the commutation rules set using Setup to sort the non-commutative operands of a product in an indicated ordering.


The Physics:-Library commands used



Library:-ApplyProductsOfDifferentialOperators applies the differential operators found in a product to the product operands that appear to its right. For example, applying this command to  p*V(X)*m__e results in m__e*p(V(X))


Library:-EqualizeRepeatedIndices equalizes the repeated indices in the terms of a sum, so for instance applying this command to L[a]^2+L[b]^2 results in 2*L[a]^2




[1] W. Pauli, "On the hydrogen spectrum from the standpoint of the new quantum mechanics,” Z. Phys. 36, 336–363 (1926)

[2] S. Weinberg, "Lectures on Quantum Mechanics, second edition, Cambridge University Press," 2015.

[3] Veronika Gáliková, Samuel Kováčik, and Peter Prešnajder, "Laplace-Runge-Lenz vector in quantum mechanics in noncommutative space", J. Math. Phys. 54, 122106 (2013)

[4] Castro, P.G., Kullock, R. "Physics of the so__q(4) hydrogen atom". Theor. Math. Phys. 185, 1678–1684 (2015).

[5] L. R. U. Manssur, R. Portugal, and B. F. Svaiter, "Group-Theoretic Approach for Symbolic Tensor Manipulation," International Journal of Modern Physics C, Vol. 13, No. 07, pp. 859-879 (2002).



Download Hidden_SO4_symmetry_submitted_to_CPC.pdf (all sections open)

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

First 12 13 14 15 16 17 18 Last Page 14 of 52