Maplesoft’s CEO, Dr. Laurent Bernardin, has written an opinion piece on Fostering Student Retention through Success in Mathematics. In it, he discusses ways to reduce university dropout rates by turning the technology shortcuts students are already using in their math courses into data-driven insights and interventions that promote student success.

You can read the whole article here:  Fostering Student Retention through Success in Mathematics

You will not be shocked to learn that Maplesoft plays a role in the strategy he proposes. 😊 (But this is a serious problem for a lot of schools, and we really would like to help!)

For a long time, triggered by a disagreement with one of my teachers, I wanted to demonstrate that Euler equations are not absolutely necessary to reproduce gyroscopic effects. Back then, there were no computer tools like Maple or programming languages with powerful libraries like Python. Propper calculations by hand (combining Newton’s equations and vector calculus) would have required days without guarantee of immediate success. Overall, costs and risks were too high to go into an academic argument with someone in charge of grading students.

Some years ago, I remembered the unfinished discussion with my teacher and simulated with MapleSim the simple gyroscope with two point masses that I had in mind at the time. It took only 10 minutes to demonstrate that I was right. At least I thought so. As I discovered recently when investigating the intermediate axis theorem, MapleSim derives behind the scenes Euler equations. This devalued the demonstration.

This post is about a second and successful attempt of a demonstration with Maple employing Lagrangian mechanics.  A rotating system of three point masses connected by rigid struts is used. The animation below from the attached Maple worksheet exactly reproduces a simulation of an equivalent T-shaped structure of three identical masses presented here.

Lagrangian Mechanics

The worksheet uses Lagrangian mechanics to derive equations of motion. Only translational energy terms are used in the Lagrangian to prevent Euler equations from being derived. To account for the bound motion of the three point masses, geometric constraints with Lagrange multipliers were added to the Lagrangian L of the system. This lead to a modified Lagrangian L’ that can be used with dedicated Maple commands to derive with little effort a set of Lagrange’s equations of the first kind and the corresponding constraints

(source https://en.wikipedia.org/wiki/Lagrangian_mechanics)

For the system of three point masses the above equations lead to 9 coupled second-order ordinary differential equations (ODEs) and 3 algebraic constraints 

(Maple output from the command Physics,LagrangeEquations)

where x_i, y_i and z_i are the components of the position vectors _i of the masses 1 to 3 and the l_i,j are the constraints between the masses i and j, and b and h are the base and the height of the triangle.

The 12 equations together are also referred to as differential algebraic equations (DAEs). Maple has dedicated solvers for such systems which make implementation easy. The most difficult part is setting the initial conditions for all point masses. In this respect MapleSim is even easier to use since not all initial conditions have to be exactly defined by the user. MapleSim also detects constraints that allow for a simplification of the problem by reducing the number of variables to solve. This leads automatically to 3 instead of 12 equations to be solved. Computational effort is reduced in this way significantly.

Newtonian Mechanics

One could argue now that the above is a demonstration with Lagrangian mechanics and not with Newtonian mechanics. To treat the system in a Newtonian way, the masses must be isolated and internal forces acting on each mass via the struts are applied to each mass and effectively become external forces. This leads to 9 ODEs with 27 unknows

Following actio=reactio for each of the (massless) struts reduces the number of unknows to 18

To solve for the 18 unknows, 9 more relations are required. 3 algebraic constraints that keep the distance between the masses constant have already been listed in the previous section. 6 further algebraic constraints can be established from the fact that the force vectors point towards the opposing mass (see also below).
The effort to solve this system of equations will be even greater but with the benefit of having information about the internal forces in the system. Before making this effort, it is advisable to take a closer look at the equations of motion derived so far.

Forces and the "mysterious" Lagrange Multipliers

Rearranging equations of motion from Lagrangian mechanics to

and comparing this to the equations of motion from Newtonian mechanics yields in vector notation 

or more general for the forces

where the _i are the position vectors of the individual masses and the  are the constraint forces between them.  

In the case of a triangle formed by struts all internal forces must act in the direction of the edges of the triangle. If they would not act this way, opposing pairs of  and   would create a torque around the struts which would lead to an infinite angular acceleration of the massless struts. The above equation confirms this reasoning: The internal forces act in the direction of the difference vectors between the position vectors of the masses (which describe the edges) and scale with l_ij.

The beauty of the Lagrange multipliers in this case is that they hit 3 birds (three components of the vectors ) with one stone. This reduces the number of unknowns.

However, the Lagrange multipliers are somehow mysterious because they do not represent a physical quantity, but they can be used to calculate meaningful and correct physical results.

What makes them even more mysterious is the fact that positions constraints can be expressed in different ways. In the above example the square of the distance between the masses is kept constant instead of the distance. There are many more possibilities to formulate the constraint of constant distance and each of them results in different multipliers l_ij with different units. In principle they should all work equivalently but might not all be usable with dedicated solvers.

According to the above equation, the internal forces in a strut scale with the Lagrange multipliers and the length of the strut. During the back and forth flip of the triangle in the above animation the forces vary which can be appreciated from the l_ij in the following plot. 

Some observations:

• At the start, only the strut between the red and the green masses is tensed by centrifugal forces. This would have been intuitively expected.
• At the start, the broken symmetry in the initial conditions is already visible by the imbalance of the forces in the two other struts.
• At no time two forces are zero
• There is never compression in two struts at the same time. The existence of compression forces renders any attempt to replace the struts by cables useless
• Plotted together in 3D the Lagrange multipliers describe a seemingly perfect circle.

The last observation in particular shows that both the Lagrange multipliers and the IAT still hold some secrets that need to be clarified:

• Is it an exact circle? How to prove that?
• Does a circle appear for all initial conditions and geometries (obtuse isosceles triangles) when the intermediate axis theorem manifests?
• What does the circle represent? Is it a kind of an invariant between the Lagrange multipliers that allows the calculation of one force when the two others are known?
• Is there an analytical representation of the circle as a function of the geometry and the initial conditions?
• What determines the center, the radius and the orientation of the circle?

Conclusion

Overall, the approach of adding non-physical terms that are zero to a physical quantity (the difference between kinetic and potential energy) to derive something meaningful is not obvious at all and underlines the genius of Lagrange. For a system of three bound masses it could be used to calculate internal forces as opposed to the more common use of calculating external constraint forces. Beyond the lack of fully satisfying intuitive explanations, the IAT still offers unanswered scientific questions.

PS.: 

• The exercise was a nice cross-check of MapleSim and Maple.
• dsolve and odeplot are awsome

IAT_without_Euler_equations.mw

My maplet (author: Xavier Cormier) "sudokuvision_multithread3" allows you to generate, solve, and play nxm region sudoku puzzles. It is possible to import lists of puzzles in .csv, .sdm, and .sdk format. It loads a grid in line format. It saves puzzles in .txt and .csv format to import them on Android (Andoku3, OpenSudoku; you must re-save the file in .sdm) and on iOS (SmartSudoku, Good Sudoku). It saves game puzzles (in numbers or colors) and their solution as a .gif image.
Two possible interfaces.
Multithreading is used to generate sudoku puzzles in parallel on multiple threads: we use sequences for the random number and the number of sudokus for each thread:
e.g., [4521,7458]=s1 for the random number and [2,2]=s2 for the number of sudokus. We then generate 2[i] sudokus for the ith thread. with s1[i] as a random integer.
The maplet is compatible with Maple 2021 but not with Maple 2015.

Go to my Maple Cloud link :

https://maple.cloud/app/6283420531032064/sudoku+multithread3?key=8DBF1E6D71EF423B9BE883C27FF0FD892C14B4FCD25B4920A29AFE4E4B4363B8

My maplet (author :Xavier Cormier) studies the partitioning of a set and the decomposition of an integer into a sum.
It can be used in the case of a dice roll.

It determines:
- the number of times each face is obtained for n rolls for an m-sided die.
- the decomposition of an integer nx into the sum of mx integers.
- the partitioning of a set into u non-empty, disjoint pairwise parts.
- the partitions of an integer as well as the dice rolls having a given sum and the probability (equiprobability) of obtaining this sum.

Go to my link on Maple Cloud :

https://maple.cloud/app/6553582941372416/decomposition+d%27un+entier+en+somme+et+partage+d%27une+liste+en+parties+-+app+pour+lanc%C3%A9s+de+d%C3%A9s?key=8533B69313624ADCBE181600B15A1F4F5DDBBFAE86694B479CE492515459A2C9

Hello everyone,

I am creating this post to begin a thread where I will share a series of worksheets on important topics in Complex Analysis, written as part of my notes for my classes. Complex_Analysis_Notes.pdf

The planned sections include:

• Section 1: Infinite Series

• Section 2: Power Series

• Section 3: The Radius of Convergence of a Power Series

• Section 4: The Riemann Zeta Function and the Riemann Hypothesis

• Section 5: The Prime Number Theorem

Each worksheet will include calculations, plots, and examples using Maple to illustrate key ideas.

✅ I plan to upload one worksheet every week to keep a steady pace and allow time for discussion and feedback between posts.

I hope this thread will be helpful both for learning and for deeper exploration.
Feel free to comment, suggest improvements, or ask questions as I post the materials.

Thank you!

Download infinite_series.mw

This should be a rule. 

If replies and answers are deleted  then there must be a secondary acknowledgement from the original poster to do so.  The reply or answer can not be deleted under the response of another person and only the acknowledgment of the top poster / questioneer will that, answer/reply, be allowed to be deleted. 

Also goes with re-organizing the order of replies/answers - only happens if the person who started the thread acknowledges the action. 

Too many times have answers / replies been jumbled out of order.  Just because it makes sense for one person, doesn't mean it makes sense for everyone. 

edit added *** this is also to cure the mandella effect in this forum (or perhaps you just thought you were getting dementia) .... I swear someone answered this post but where did that answer go?  ******

L. B. Johnson once said: “I may not know much, but I know chicken sh#t from chicken salad.” And the same goes for mathematical software,  Maple is a good chicken salad.

These two numbers can be used to factor two previously factored RSA Challenge numbers:

4492372899485266683229032112393311539091890452003150017722229708882931615085372733373343061967162688807713966063216561545461119244883848142568154156987418243095913219694108294875951005535802313105656690937568115044857082104972025

252470349467980886727391223577367145704558455488893488785280129051457755334632136343591527439288590916228345021218177497619016135424030834870037054353008183582467637830682000623550252325843511739294850378626625818394419012275747807

I'm curious to see if anyone can identify the numbers and do the factorization. If no one has been able to solve this, I will post the solution context at a future date. There exists some very interesting mathematics behind this question that goes beyond a simple recreational diversion.
 

As a university-level math student, I am constantly working through practice problems. An issue I constantly face is that when I get a problem wrong, it can be challenging to find out which line I did wrong. Even if I use Maple Calculator or Maple Learn to get the full steps for a solution, it can be tedious to compare my answer to the steps to see where I went wrong.

This is why Check My Work is one of the most popular features in Maple Learn. Check My Work will check all the lines in your solution and give you feedback showing you exactly where you went wrong. I honestly didn’t know that something like this existed until I started here at Maplesoft, and it is now easy to see why this has been one of our most successful features in Maple Learn.

Students have been loving it, but the only real complaint is that it’s only available in Maple Learn. So, if you were working on paper, you'd either have to retype your work into Maple Learn or take a picture of your steps using Maple Calculator and then access it in Maple Learn. Something I immediately thought was, if I’m already on my phone to take a picture, I’d much rather be able to stay on my phone.

And now you can! Check My Work is now fully available within Maple Calculator!

To use Check My Work, all you need to do is take a picture of your solution to a math problem.

Check My Work will recognize poor handwriting, so there is no need to worry about getting it perfect. After taking the picture, select the Check My Work dropdown in the results screen to see if your solution is correct or where you made a mistake.

Check My Work will go through your solution line-by-line giving you valuable feedback along the way! Additionally, if you make a mistake, Maple Calculator will point out the line with the error and then proceed with checking the remainder of the solution given this context.  

For students, Check My Work is the perfect tool to help you understand and master concepts from class. As a student myself, I’ll for sure be using this feature in my future courses to double-check my work.

What makes Check My Work great for learning a technique is that it doesn’t tell you what mistake you made, but rather where the mistake has been made. This is helpful since as a student you don’t have to worry about the time-consuming task of finding the step with an error, but rather you can focus on the learning aspect of actually figuring out what you did wrong.

Once you have made corrections to your work on paper, take a new picture and repeat the process. You can also make changes to your solution in-app by clicking the “Check my work in editor” button in the bottom right, which runs Check My Work in the editor where you can modify your solution.

No other math tool has a Check My Work feature, and we are very proud to bring this very useful tool to students. By bringing it fully into Maple Calculator, we continue working towards our goal of helping students learn and understand math.

View the GIF below for a brief demonstration of how to use Check My Work!

We hope you enjoy Check My Work in Maple Calculator and let us know what you think!

Maplesoft now has a new approach to providing customer support for Maple users! The Maple Customer Support Updates allows Maplesoft to provide important updates to our customers as fast as possible. These updates contain a series of improvements and fixes to any area of the Maple library, enabling a rapid response for customer reports and requests. When a Maple user reports a bug or weakness, or requests some missing functionality that can be addressed with an update to the Maple library, such an update can now be provided immediately after the fix or improvement is developed. Furthermore, the update will not just be available to that customer who reported it, but also to any other Maple users who wishes to use them. Of course, not all reports will be able to be addressed quickly, and for those that are, it will be up to the developer's discretion whether to make the fix or improvement available via these new Maple Customer Support Updates. Please note that these Updates may contain experimental elements that could change in subsequent official releases.

The updates are available as a workbook containing a Maple library file that can be downloaded and installed from the Maple Cloud. To install the Maple Customer Support Updates from the Maple Cloud,

• Click the MapleCloud icon in the upper-right corner of the Maple GUI window and select Packages.
• Find the Maple Customer Support Updates package and click the Install button, the last one under Actions.
• To check for new versions of Maple Customer Support Updates, click the MapleCloud icon and select Updates. If the cloud icon in the Actions column of Maple Customer Support Updates has the word Update beside it, then you can click on it to download a new update.

To make the process of installing and maintaining the Maple Customer Support Updates as smooth as possible, we've also introduced a new Maple library package, SupportTools, with 3 commands, Update, Version, and RemoveUpdates.

The procedure gives the bilinear form of a non-linear pde 
Output is not quite in an easy-to-read notation yet , but will come later on as an option in the procedure call of bilinear ( , option) 
Depends what further to do with the changed pde in Hirato D-operator form?..using a ansatz ( try function with reason) 

>  with(PDEtools): with(DEtools): ## Hirota Bilinear Method ## Bilinear Derivative / Hirota Operator BD := proc(FF, DD)     local f, g, x, m, opt;     if nargs = 1 then         return `*`(FF[]);     fi;     f, g := FF[];     x, m := DD[];     opt := args[3..-1];     if m = 0 then         return procname(FF, opt);     fi;     procname([diff(f, x), g], [x, m-1], opt) - procname([f, diff(g, x)], [x, m-1], opt); end: `print/BD` := proc(FF, DD)     local f, g, x, m, i;     f, g := FF[];     f := cat(f, ` `, g);     g := product(D[args[i][1]]^args[i][2], i = 2..nargs);     if g <> 1 then         f := ``(g)*``(f);     fi;     f; end: ## collect(expr, f); first! getFnumer := proc(df, f, pow::posint := 1)     local i, g, fdenom;     if type(df, `+`) then         g := [op(df)];         fdenom := map(denom, g);         for i to nops(fdenom) while fdenom[i] <> f^pow do         od;         if i > nops(fdenom) then             lprint(fdenom);             error "no term(s) or numer=0 when denom=%1", op(0, f)^pow;         fi;         g := numer(g[i]);         if not type(expand(g), `+`) then             lprint(g);             error "Expected more than 1 term about Hirota D-operator";         fi;         return g;     fi;     lprint(df);     error "expected 1st argument be type `+`."; end: getvarpow := proc(df::function)     local i, f, var, dif, pow;     if op(0, df) <> diff then         lprint(df);         error "expected diff function";     fi;     f := convert(df, D);     var := [op(f)];     dif := [op(op([0, 0], f))];     pow := [0$nops(var)];     f := op(op(0, f))(var[]);     for i to nops(var) do         dif := selectremove(member, dif, {i});         pow[i] := nops(dif[1]);         dif := dif[2];     od;     pow := zip((x, y) -> [x, y], var, pow);     pow := remove(has, pow, {0});     [[f, f], pow[]]; end: #convert to Hirota Bilinear Form HBF := proc(df)     local i, c, f;     if type(df, `+`) then         f := [op(df)];         return map(procname, f);     fi;     if type(df, `*`) then         f := [op(df)];         f := selectremove(hasfun, f, diff);         c := f[2];         f := f[1];         if nops(f) <> 1 then             lprint(df);             error "need only one diff function factor.";         fi;         f := f[];         c := `*`(c[]);         f := getvarpow(f);         f := [c, f];         return f;     fi;     if op(0, df) = diff then         f := getvarpow(df);         f := [1, f];         return f;     fi;     lprint(df);     error "unexpected type."; end: printHBF := proc(PL::list)     local j, DD, f, C, tmp, gcdC, i;     C := map2(op, 1, PL);     gcdC := 1;     if nops(C) > 1 then         tmp := [seq(cat(_Z, i), i = 1..nops(C))];         gcdC := tmp *~ C;         gcdC := `+`(gcdC[]);         gcdC := factor(gcdC);         tmp := selectremove(has, gcdC, tmp);         gcdC := tmp[2];         if gcdC = 0 then             gcdC := 1;         fi;         gcdC := gcdC*content(tmp[1]);     fi;     if gcdC <> 1 then         C := C /~ gcdC;     fi;     DD := map2(op, 2, PL);     f := op(0, DD[1][1][1]);     DD := map(z -> product(D[z[i][1]]^z[i][2], i = 2..nops(z)), DD);     DD := zip(`*`, C, DD);     DD := `+`(DD[]);     gcdC * ``(DD) * cat(f, ` `, f); end: ## print Hirota Bilinear Transform printHBT := proc(uf, u, f, i, j, PL, alpha := 1)     local DD, g, C, tmp, pl;     pl := printHBF(PL);     if j > 0 then         print(u = 2*alpha*'diff'(ln(f), x$j));     else         print(u = 2*alpha*ln(f));     fi;     if i > 0 then         print('diff'(pl/f^2, x$i) = 0);     else        print(pl/f^2 = 0);     fi;     NULL;  end: guessdifforder := proc(PL::list, x::name)     local L, minorder, maxorder, tmp;     L := map2(op, 2, PL);     L := map(z -> z[2..-1], L);     tmp := map(z -> map2(op, 2, z), L);     tmp := map(z -> `+`(z[]), tmp);     tmp := selectremove(type, tmp, even);     minorder := 0;     if nops(tmp[1]) < nops(tmp[2]) then         minorder := 1;     fi;     tmp := map(z -> select(has, z, {x}), L);     tmp := map(z -> map2(op, 2, z), tmp);     if has(tmp, {[]}) then         maxorder := 0;     else         tmp := map(op, tmp);         maxorder := min(tmp[]);     fi;     if type(maxorder - minorder, odd) then         maxorder := maxorder - 1;     fi;     [minorder, maxorder]; end: guessalpha := proc(Res, uf, u, f, i, j, PL, alpha)     local tmp, res, pl, flag, k;     flag := 1;     tmp := [op(Res)];     tmp := map(numer, tmp);     tmp := gcd(tmp[1], tmp[-1]);     if type(tmp, `*`) then         tmp := remove(has, tmp, f);     fi;     if tmp <> 0 and has(tmp, {alpha}) then         tmp := solve(tmp/alpha^difforder(uf), {alpha});         if tmp <> NULL and has(tmp, {alpha}) then             lprint(tmp);             for k to nops([tmp]) while flag = 1 do                 res := collect(expand(subs(tmp[k], Res)), f, factor);                 if res = 0 then                     pl := subs(tmp[k], PL);                     printHBT(uf, u, f, i, j, pl, rhs(tmp[k]));                     flag := 0;                 fi;             od;         fi;     fi;     PL; end: Bilinear := proc(uf, u, f, x, alpha)     local su, h, i, j, g1, CB, PL, gdo, DD, Res;     if hasfun(uf, int) then         error "Do not support integral function yet. Please substitute int function.";     fi;     for j from 0 to 2 do         Res := 1;         su := u = 2*alpha*diff(ln(f), [x$j]);         h := collect(expand(dsubs(su, uf)), f, factor);         if hasfun(h, ln) then             next;         fi;         g1 := getFnumer(h, f)/2;         g1 := expand(g1);         CB := HBF(g1);         gdo := guessdifforder(CB, x);         for i from gdo[1] by 2 to gdo[2] do             if i = 0 then                 PL := CB;             else                 PL := HBF(int(g1, x$i));             fi;             DD := add(PL[i][1]*BD(PL[i][2][]), i = 1..nops(PL));             Res := collect(expand(diff(DD/f^2, [x$i]) - h), f, factor);             if Res = 0 then                 printHBT(uf, u, f, i, j, PL, alpha);                 break;             elif type(alpha, name) and has(DD, alpha) then                 Res := guessalpha(Res, uf, u, f, i, j, PL, alpha);             fi;         od;         if Res = 0 then             break;         fi;     od;     PL; end: >  with(PDEtools): # Definieer de Boussinesq vergelijking boussinesq := diff(u(x,t),t,t) - diff(u(x,t),x,x) - 3*diff(u(x,t),x,x)^2 - diff(u(x,t),x$4); # Pas de bilineaire transformatie toe Bilinear(boussinesq, u(x,t), f(x,t), x, alpha); {alpha = 1}   (1) >    >  # Definieer de Kadomtsev–Petviashvili (KP) vergelijking in één regel kp := diff(diff(u(x,y,t),x$3) + 6*u(x,y,t)*diff(u(x,y,t),x) + diff(u(x,y,t),t), x)        + 3*delta^2*diff(u(x,y,t), y$2): Bilinear(kp, u(x,y,t), f(x,y,t), x, alpha);   {alpha = 1}   (2) >

printHBF := proc(PL::list) ? 

Download dbilinear_proc_def_13-4-2025.mw

In Statistics Library there is an error with PowerFit function. The summarize of results show R-Squared and Adjusted R-Squared with erroneal results. Please could you fix it?

I teach math at the high school level.

I am worried that Maple 2025 appears to be slower than Maple 2024 - in particular for students with older, less strong laptops.

Maple 2025 takes 50% longer to start than Maple 2024 (or Maple 2025 Screen Reader which I expect to be using).

So, on more sluggist student laptops I fear the slowness overall will be an issue - in particular as Maple regularly has to be shutdown and restarted for some of those students.

Further, I really miss the "recompute section !" and the "magniffy" icons on the quest access bar. Having "recompute entire worksheet !!!" seems unwise though. I wish you could costumize the quest access bar.

Overall, from a teaching point of view, I am not at all impressed, sadly.

Approximation_of_ODEs_with_Cubic_Splines.mw

Just an observation.

I was wondering if less obvious errors than in the below can be avoided with future versions of the AI assistant. Maybe a warning that a formula uses special Maple symbols is possible.

Formulas without dimensions are more susceptible to undetected errors.

Download AI_formula_assistant.mw

P.S.:

This is a real example that happend to me where I did not notice the minus sign in Maples output in equation (1). The error  can easily be fixed by adding "local I" as the first statement of the document and the deflection becomes 1 mm.