Maple 2026 Questions and Posts

These are Posts and Questions associated with the product, Maple 2026

Can the AI Assistant in the Maple 2026 GUI be configured to use Anthropic's Claude Max plans, local AIs (e.g., via LM Studio), or other providers?

I am only occasionally using Maple versions with the new ribon user interface and noticed about 2 weeks ago that I cannot interrupt for loops under these interfaces. For example this one

for i to 1000 do
    i^i;
end do

I re-run the code today (after installing windows updates) and could interrupt before the screen was filled with output but not after executing the code a second time (without restart).

Is that reproducible on other installations?

Are there other commands that cannot be interrupted? 
If that is known, are there workarounds?

Update:
I have restarted Maple and have two worksheets open with the same code. I can repeatedly interrupt in one worksheet but not in other

Could anyone tell me what type of matrix normalisation this is and it it built into Maple? I found this in a paper and Google AI said this is the process of normailsation being used.

restart

with(LinearAlgebra):

J:=Matrix([[ 1 , 0 , 0 ],
        [ 0 , 1 , 0 ],
        [ 0 , 0 , -1 ]]);

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = -1})

(1)

Matrix N has already been scaled, so the rows are of equal magnitude  x^2 + y^2 - z^2= k

N:=Matrix(3, 3, [[4, -3, 2], [-1/2*sqrt(70), -3/10*sqrt(70), 1/5*sqrt(70)], [1/11*sqrt(77), 6/11*sqrt(77), 2/11*sqrt(77)]])

Matrix(3, 3, {(1, 1) = 4, (1, 2) = -3, (1, 3) = 2, (2, 1) = -(1/2)*sqrt(70), (2, 2) = -(3/10)*sqrt(70), (2, 3) = (1/5)*sqrt(70), (3, 1) = (1/11)*sqrt(77), (3, 2) = (6/11)*sqrt(77), (3, 3) = (2/11)*sqrt(77)})

(2)

 

for i to 3 do
add(N[i,j]^2,j=1..2)-N[i,3]^2;
end do

21

 

21

 

21

(3)

Normalisation process to produce C

A:=N.J.N^%T

Matrix(3, 3, {(1, 1) = 21, (1, 2) = -(3/2)*sqrt(70), (1, 3) = -(18/11)*sqrt(77), (2, 1) = -(3/2)*sqrt(70), (2, 2) = 21, (2, 3) = -(27/110)*sqrt(70)*sqrt(77), (3, 1) = -(18/11)*sqrt(77), (3, 2) = -(27/110)*sqrt(70)*sqrt(77), (3, 3) = 21})

(4)

dA:=DiagonalMatrix(1/~(sqrt~(abs(Diagonal((A))))));

Matrix(3, 3, {(1, 1) = (1/21)*sqrt(21), (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = (1/21)*sqrt(21), (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = (1/21)*sqrt(21)})

(5)

C:=(dA.A.dA);

Matrix(3, 3, {(1, 1) = 1, (1, 2) = -(1/14)*sqrt(70), (1, 3) = -(6/77)*sqrt(77), (2, 1) = -(1/14)*sqrt(70), (2, 2) = 1, (2, 3) = -(9/770)*sqrt(70)*sqrt(77), (3, 1) = -(6/77)*sqrt(77), (3, 2) = -(9/770)*sqrt(70)*sqrt(77), (3, 3) = 1})

(6)

evalf(C)

Matrix(3, 3, {(1, 1) = 1., (1, 2) = -.5976143047, (1, 3) = -.6837634587, (2, 1) = -.5976143047, (2, 2) = 1., (2, 3) = -.8581163304, (3, 1) = -.6837634587, (3, 2) = -.8581163304, (3, 3) = 1.})

(7)
 

 

Download 2026-08-14_Q_What_Type_of_Matrix_Normalisation.mw

You are hosting a big party tonight and prepared 1000 bottles of wine. A spiteful neighbor sneaks in and poisons exactly one bottle. The poison is colorless, tasteless, and takes about an hour to take effect and kill. Your party also starts in an hour, and you don’t want to throw all the wine away.

You have 10 mice and time for only one round of tasting. In that round, a mouse can taste from any number of bottles. How can you identify that single poisoned bottle among 1000?

Pause here and try to solve the problem yourself!

An obvious solution might be to group the wine into 10 batches of 100 bottles and have each mouse drink from one batch. But if a mouse dies, you have only narrowed it down to 100 bottles, and there is no time for a second round. Whatever test you run, you only get one shot.

Ten mice. A thousand bottles. The problem sounds impossible – until you realize each mouse isn’t just a taster.

The exact idea that powers computers is also what solves our wine puzzle.

A 300-Year-Old Idea

Some background information before we solve the problem.

In 1703, Gottfried Leibniz published a paper describing how every number can be written using only two symbols: 0 and 1. To him, the concept felt almost divine – an entire universe created out of nothingness and unity. But for over two centuries, binary remained an idea trapped on paper.

Everything changed when a young engineer named Claude Shannon realized that 0 and 1 map perfectly onto the physical states of an electrical switch: off and on. That single insight laid the groundwork for digital circuits, eventually powering every smartphone, laptop, and text message on the planet.

Yet binary is more than just how machines store information. It is a way of extracting information.

0 and 1 not only reflect the underlying logic of switches, but they also correspond to every yes/no question you ask: “did this mouse die, or not?”. And 10 binary digits can cover 2¹⁰ = 1024 different possibilities.

1024 is more than 1000.

The Solution  

Step 1: Relabel the bottles in binary

Write each bottle’s number, 1 through 1000, as a 10-digit binary number, padding the front with 0s. For example, bottle 17 is 10001 in binary, so its label becomes 0000010001. Every bottle now carries a unique 10-digit barcode of 0s and 1s.

Step 2: Assign each mouse a digit

Line up the mice and assign each one a digit: mouse #1 owns the leftmost digit, mouse #10 the rightmost. Then, run the tasting by the simple rule of a mouse drinks from a bottle if and only if its digit in that bottle’s label is a 1.

For bottle 17, only mouse #6 and mouse #10 take a sip. No two bottles are sampled by the same combination of mice; each bottle’s binary label is its unique drinking pattern.

Step 3: Read the answer off the casualties

Wait an hour. Then, write a 1 in every position with a dead mouse and a 0 otherwise. The string you end up with is the binary label of the poisoned bottle.

One More Sip

Before you pop the corks, one last question: was the binary system essential here, or could we have used a different method?

Here’s a food for thought: suppose your neighbor used a cheaper poison that kicks in 30 minutes instead of an hour, now there is time for a second round of tasting.

Now each mouse has three possible outcomes instead of two: dies in round 1, dies in round 2, or survives. Binary is the wrong language here; you want base 3.

The scheme goes as follows. Label the bottles in base 3, give each mouse a digit position, and follow one rule: if digit 1, drink in round 1; if digit 2, drink in round 2; if digit 0, sit out. Each mouse’s fate is its digit on the poisoned bottle’s label.

The ternary system’s power grows exponentially. Ten mice can now handle 3¹⁰ = 59049 bottles – our 1000 can be covered by seven mice (3⁷ = 2187). Generalized, with r rounds, the whole construction runs in base r+1.

That is the lesson hidden in the wine cellar. The binary system is more than the foundation of our telecom network, it is also a way of thinking – a reminder that any question, no matter how large, can be answered by a patient sequence of yes and no. You walked into an impossible evening with ten mice and walked out with 999 bottles of perfectly good wine.

Enjoy the party.

In late July, the International Congress on Mathematical Software (ICMS 2026) came to the University of Waterloo and Wilfrid Laurier University. Maplesoft had the privilege of sponsoring this year's event, and on the first evening of the conference we opened our Waterloo office for a reception, welcoming around 140 researchers, professors, students, and developers from around the world for an evening of food, demos, and good conversation. Among the many brilliant guests were the ICMS General Chair Bernard Mourrain and Local Organization Chairs Stephen M. Watt and Ilias S. Kotsireas.


About 30 of us pitched in to organize, demo, and host, turning our office into a packed social hub for the evening. Our CEO, Dr. Laurent Bernardin, opened the evening with some welcome remarks and a talk on math education in the age of AI, tying into the recent launch of the Math Success Platform - a new tool built on Maple to help educators understand where students are struggling and provide more targeted support.

I, alongside the other co-op students for this term, got the opportunity to volunteer at one of the demo booths, where we showed off the new AI Assistant and Document Import features in Maple 2026, as well as the Maple MCP Server. Two live examples in particular seemed to resonate quite well with our guests...

The first was a demonstration of the Document Import tool. We brought messy handwritten multivariable calculus notes, outlining limit definitions and squeeze theorem example problems, and scanned them directly into Maple. Within seconds, the handwriting was converted into a functional Maple worksheet, math and all, right down to preserving the hand-drawn graphs. The worksheet was ready to be edited and executed just like anything typed in natively. A skeptical guest even asked us to scan their research papers - written completely in German - just to see the import work in this case as well, and it did, intelligently creating a worksheet with collapsible sections for each individual topic. For a room full of people who spend their careers working with mathematical software, this feature got a reaction every single time.

The second was Maple's AI assistant, specifically its ability to generate and debug Maple code within the context of your workspace. We loaded a worksheet with a spherical coordinates problem - calculating the volume of the upper half of a sphere with radius 4 - and simply prompted the AI Assistant to create a 3D diagram with interactive sliders to help visualize the problem. Moments later, it had analyzed the sheet and written a working code block for generating a fully interactive 3D visualization, letting guests drag each slider and watch the diagram update in real time across the sphere. It turned an abstract triple integral into something you could physically manipulate and understand, which for a lot of students really helps make these topics click.

Working the demo booth was a rewarding experience for all of us co-op students, as researchers asked some tough, thought-provoking questions that pushed us to think on our feet and imagine new ways to use the very tools we were demonstrating.
Beyond the demos, it was also just a great chance to talk with inspiring figures in the world of mathematics - hearing what ambassadors are building with Maple day-to-day, swapping stories with both students and professors on their academic experiences, and getting a glimpse into just how wide and varied the math software community really is. It's not every day that I get to spend time chatting with the people actually shaping the field I'm studying.

Thank you to the ICMS for bringing the international math software community to our door. It made for one of the most memorable evenings of our time as Maplesoft co-op students!

I am trying to add this to my type list in a package, but cannot get it to work.

TypeTools:-AddType(_L3DP, set(satisfies(s -> type(s, [algebraic $ 3])),'Vector[column](3, algebraic)'));

when I test with this I get an error.

 type({[7,8,9],<1,2,3>},:-_L3DP);
Error, testing against an invalid type

or this 

type({[7,8,9],<1,2,3>},set(satisfies(s -> type(s, [algebraic $ 3])),'Vector[column](3, algebraic)'));
Error, testing against an invalid type

This the part of a procedure I have for removing common factors from matrices and vectors used in a projective geometry setting.
How can a get it to work so it handles polynomial denominators? Such as 

x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2

restart

 

ReduceM:= proc(C::{Matrix, :-_ProjM3})
            local i, tgdc, dnm, V1, Ml, SV1, ns, M, r;
            option overload;
            if C::'Matrix' then
                M := LinearAlgebra:-Copy(C);
            elif C::{':-_ProjM3'} then
                M := LinearAlgebra:-Copy(C[1]);
            end if;
            V1 := convert(M, list);
            SV1 := convert(M, set) minus {0};
            ns := nops(SV1);
            dnm := frontend(lcm, [seq(denom(SV1[i]), i = 1 .. ns)]);
            Ml := simplify(dnm *~ M);
            V1 := convert(Ml, list);
            tgdc := SV1[1];
            if tgdc = 0 then
                tgdc := 1;
            end if;
            for i from 2 to ns do
                tgdc := frontend(gcd, [tgdc, SV1[i]]);
            end do;
            r := `if`(C::'Matrix', simplify(factor~(Ml /~ tgdc)),
                <[simplify(factor~(Ml /~ tgdc))]>);
            return r;
        end proc:

 

 

A:=Matrix(3, 3, [[(x__2 - x__1)*(-y__2 + y__3) + (-y__1 + y__2)*(-x__3 + x__2), (x__2 - x__1)*(-y__1 + y__3) + (-y__1 + y__2)*(-x__3 + x__1), (x__2 - x__1)*(-y__1 + y__2) + (-y__1 + y__2)*(-x__2 + x__1)], [(x__3 - x__1)*(-y__2 + y__3) + (-y__1 + y__3)*(-x__3 + x__2), (x__3 - x__1)*(-y__1 + y__3) + (-y__1 + y__3)*(-x__3 + x__1), (x__3 - x__1)*(-y__1 + y__2) + (-y__1 + y__3)*(-x__2 + x__1)], [x__1*(-y__2 + y__3) + y__1*(-x__3 + x__2) - x__2*y__3 + x__3*y__2, (-y__1 + y__3)*x__1 + y__1*(-x__3 + x__1) - x__1*y__3 + x__3*y__1, (-y__1 + y__2)*x__1 + y__1*(-x__2 + x__1) - x__1*y__2 + x__2*y__1]])

Matrix(3, 3, {(1, 1) = (x__2-x__1)*(-y__2+y__3)+(-y__1+y__2)*(-x__3+x__2), (1, 2) = (x__2-x__1)*(-y__1+y__3)+(-y__1+y__2)*(-x__3+x__1), (1, 3) = (x__2-x__1)*(-y__1+y__2)+(-y__1+y__2)*(-x__2+x__1), (2, 1) = (x__3-x__1)*(-y__2+y__3)+(-y__1+y__3)*(-x__3+x__2), (2, 2) = (x__3-x__1)*(-y__1+y__3)+(-y__1+y__3)*(-x__3+x__1), (2, 3) = (x__3-x__1)*(-y__1+y__2)+(-y__1+y__3)*(-x__2+x__1), (3, 1) = x__1*(-y__2+y__3)+y__1*(-x__3+x__2)-x__2*y__3+x__3*y__2, (3, 2) = (-y__1+y__3)*x__1+y__1*(-x__3+x__1)-x__1*y__3+x__3*y__1, (3, 3) = (-y__1+y__2)*x__1+y__1*(-x__2+x__1)-x__1*y__2+x__2*y__1})

(1)

ReduceM(A)

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 1, (1, 3) = 0, (2, 1) = 1, (2, 2) = 0, (2, 3) = -1, (3, 1) = -1, (3, 2) = 0, (3, 3) = 0})

(2)

B:=Matrix(3, 3, [[-(y__1 - y__3)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2) + (y__1 - y__2)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2), -(y__1 - y__3)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2), -(y__1 - y__2)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2)], [(-x__3 + x__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2) - (-x__2 + x__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2), (-x__3 + x__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2), (-x__2 + x__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2)], [-(x__1*y__3 - x__3*y__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2) + (x__1*y__2 - x__2*y__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2) - 1, -(x__1*y__3 - x__3*y__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2), -(x__1*y__2 - x__2*y__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2)]])

Matrix(3, 3, {(1, 1) = -(y__1-y__3)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)+(y__1-y__2)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (1, 2) = -(y__1-y__3)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (1, 3) = -(y__1-y__2)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (2, 1) = (-x__3+x__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)-(-x__2+x__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (2, 2) = (-x__3+x__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (2, 3) = (-x__2+x__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (3, 1) = -(x__1*y__3-x__3*y__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)+(x__1*y__2-x__2*y__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)-1, (3, 2) = -(x__1*y__3-x__3*y__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (3, 3) = -(x__1*y__2-x__2*y__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)})

(3)

ReduceM(B)

Error, (in gcd/Freeze) arguments should be polynomials

 

B*denom(B[1,1])

Matrix(3, 3, {(1, 1) = (x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)*(-(y__1-y__3)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)+(y__1-y__2)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)), (1, 2) = -y__1+y__3, (1, 3) = -y__1+y__2, (2, 1) = (x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)*((-x__3+x__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)-(-x__2+x__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)), (2, 2) = -x__3+x__1, (2, 3) = -x__2+x__1, (3, 1) = (x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)*(-(x__1*y__3-x__3*y__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)+(x__1*y__2-x__2*y__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)-1), (3, 2) = -x__1*y__3+x__3*y__1, (3, 3) = -x__1*y__2+x__2*y__1})

(4)

simplify( (4) );

Matrix(3, 3, {(1, 1) = -y__2+y__3, (1, 2) = -y__1+y__3, (1, 3) = -y__1+y__2, (2, 1) = -x__3+x__2, (2, 2) = -x__3+x__1, (2, 3) = -x__2+x__1, (3, 1) = -x__2*y__3+x__3*y__2, (3, 2) = -x__1*y__3+x__3*y__1, (3, 3) = -x__1*y__2+x__2*y__1})

(5)
 

 

Download 2026-08-03_Q_Remove_Common_Factors_from_Matrix.mw

Does GuessRecurrence require at least 7 terms in its input list?

For a numericial integration I want to check if all physical parameters are given in SI base units (before stripping of the units for the integration). Right now I am doing this

restart

Parameters

H = 0.1e-1*Unit('m'), R = 0.6e-2*Unit('m'), r_sub = 0.3e-2*Unit('m'), k = .540*Unit('W'/('m'*'K')), rho = 1060.0*Unit('kg'/'m'^3), Cp = 3745*Unit('J'/('kg'*'K')), Q_flux = 5000*Unit('W'/'m'^2), T_amb = 0*Unit('K'), Nz = 20, Nr = 20, t_final = 30*Unit('s'), t_step = Unit('s'), test_1 = Unit('kW'), test_2 = 2*Unit('N')

H = 0.1e-1*Units:-Unit(m), R = 0.6e-2*Units:-Unit(m), r_sub = 0.3e-2*Units:-Unit(m), k = .540*Units:-Unit(W/(m*K)), rho = 1060.0*Units:-Unit(kg/m^3), Cp = 3745*Units:-Unit(J/(kg*K)), Q_flux = 5000*Units:-Unit(W/m^2), T_amb = 0, Nz = 20, Nr = 20, t_final = 30*Units:-Unit(s), t_step = Units:-Unit(s), test_1 = Units:-Unit(kW), test_2 = 2*Units:-Unit(N)

(1)

H: length of rod
R: outer radius
r_sub: outer radius of heat flux
k: conductance
ρ: density
Cp: heat capacity
Q_flux: heat flux
T_amb: initial Tempearture
Nz: number of axial grid points
Nr: number of radial grid points
t_final: integration time
t_step: sampling interval for temperature fields
test_1: unit given in kilos
test_2: unit given in derived base units

alpha = k/(rho*Cp); simplify(subs(H = 0.1e-1*Units:-Unit(m), R = 0.6e-2*Units:-Unit(m), r_sub = 0.3e-2*Units:-Unit(m), k = .540*Units:-Unit(W/(m*K)), rho = 1060.0*Units:-Unit(kg/m^3), Cp = 3745*Units:-Unit(J/(kg*K)), Q_flux = 5000*Units:-Unit(W/m^2), T_amb = 0, Nz = 20, Nr = 20, t_final = 30*Units:-Unit(s), t_step = Units:-Unit(s), test_1 = Units:-Unit(kW), test_2 = 2*Units:-Unit(N), %))

alpha = 0.1360304305e-6*Units:-Unit(m^2/s)

(2)

α: thermal diffusivity

 

One way is to check whether the value of a physical parameter has not changed after simplification

`minus`(map(convert, simplify(`~`[rhs]({Cp = 3745*Units:-Unit(J/(kg*K)), H = 0.1e-1*Units:-Unit(m), Nr = 20, Nz = 20, Q_flux = 5000*Units:-Unit(W/m^2), R = 0.6e-2*Units:-Unit(m), T_amb = 0, k = .540*Units:-Unit(W/(m*K)), r_sub = 0.3e-2*Units:-Unit(m), rho = 1060.0*Units:-Unit(kg/m^3), t_final = 30*Units:-Unit(s), t_step = Units:-Unit(s), test_1 = Units:-Unit(kW), test_2 = 2*Units:-Unit(N)})), unit_free), map(convert, `~`[rhs]({Cp = 3745*Units:-Unit(J/(kg*K)), H = 0.1e-1*Units:-Unit(m), Nr = 20, Nz = 20, Q_flux = 5000*Units:-Unit(W/m^2), R = 0.6e-2*Units:-Unit(m), T_amb = 0, k = .540*Units:-Unit(W/(m*K)), r_sub = 0.3e-2*Units:-Unit(m), rho = 1060.0*Units:-Unit(kg/m^3), t_final = 30*Units:-Unit(s), t_step = Units:-Unit(s), test_1 = Units:-Unit(kW), test_2 = 2*Units:-Unit(N)}), unit_free))

{1000}

(3)

if is(`minus`(map(convert, simplify(`~`[rhs]({Cp = 3745*Units:-Unit(J/(kg*K)), H = 0.1e-1*Units:-Unit(m), Nr = 20, Nz = 20, Q_flux = 5000*Units:-Unit(W/m^2), R = 0.6e-2*Units:-Unit(m), T_amb = 0, k = .540*Units:-Unit(W/(m*K)), r_sub = 0.3e-2*Units:-Unit(m), rho = 1060.0*Units:-Unit(kg/m^3), t_final = 30*Units:-Unit(s), t_step = Units:-Unit(s), test_1 = Units:-Unit(kW), test_2 = 2*Units:-Unit(N)})), unit_free), map(convert, `~`[rhs]({Cp = 3745*Units:-Unit(J/(kg*K)), H = 0.1e-1*Units:-Unit(m), Nr = 20, Nz = 20, Q_flux = 5000*Units:-Unit(W/m^2), R = 0.6e-2*Units:-Unit(m), T_amb = 0, k = .540*Units:-Unit(W/(m*K)), r_sub = 0.3e-2*Units:-Unit(m), rho = 1060.0*Units:-Unit(kg/m^3), t_final = 30*Units:-Unit(s), t_step = Units:-Unit(s), test_1 = Units:-Unit(kW), test_2 = 2*Units:-Unit(N)}), unit_free)) <> {}) then print("Not all units are in SI base units") end if

"Not all units are in SI base units"

(4)

Download check_for_SI_base_units.mw

I am interested in simpler ways to perform the test. The statement is quite long and not easy to understand.

Given the size of the unit package, there might be a command that I have overlooked to check whether units are in SI base units.

Have I missed test cases to make the check fool proof?

 

Update: A variant with split was added and attempts with functional programming

check_for_SI_base_units_02.mw

Has anyone developed an Agent Skill for Maple compliant with the Agent Skills Specification?

I frequently use Claude Code to create and edit Maple Documents. It does fine alone, but I found adding a script to do a syntax check eliminated a lot of content errors. I also presume some instructions on how it should read the Maple documentation will improve its reliability. Before I go about writing my own Skill against the specification, I just want to check if there is already one in use within the community.

I am trying to follow a series of substitutions used in a paper. I have given some examples of the substitutions. But I am having difficulty getting them to work. I know if all else fails I can manually recreate an expression with the substitution variables and then check backwards using eval(f,vals).
Would appreciate any insight on substitution techniques here.
 

restart

 

sidrels := [a*c - b^2 = Delta, a + c - 2*b = d, a - b = c__bar, a - c = b__bar, c - b = a__bar];

[a*c-b^2 = Delta, a+c-2*b = d, a-b = c__bar, a-c = b__bar, c-b = a__bar]

(1)

vals:='rhs=lhs'~(sidrels)

[Delta = a*c-b^2, d = a+c-2*b, c__bar = a-b, b__bar = a-c, a__bar = c-b]

(2)

t1:=a + c - 2*b;
simplify(t1,sidrels); #this should be d

a+c-2*b

 

d

(3)

t2:=Vector[column](3, [-a + b, c - b, 0]);
simplify(t2,sidrels) ; # This should be <-c__bar,a__bar,0> or <c__bar,-a__bar,0,>r

Vector(3, {(1) = -a+b, (2) = c-b, (3) = 0})

 

Vector[column](%id = 36893490321805397396)

(4)

t3:=normal(1 - b^2/(a*c));

(a*c-b^2)/(a*c)

(5)

simplify((5),sidrels); # This should be Delta/(a*c)

Delta/(b^2+Delta)

(6)

simplify(numer((5)),sidrels,'mindeg')/(denom((5)) ); # This works

 

Delta/(a*c)

(7)

t4:=[(-b^2 + b*c)/(a*c - b^2), (a*b - b^2)/(a*c - b^2)]

[(-b^2+b*c)/(a*c-b^2), (a*b-b^2)/(a*c-b^2)]

(8)

simplify(t4,sidrels,'mindeg');# this should be [(b*a__bar)/Delta, (b*b__bar)/Delta]

[-b*(-c+b)/Delta, b*(a-b)/Delta]

(9)

t5:=simplify(Vector[column](3, [3*b*c__bar - Delta, -3*a__bar*b + Delta, b*(-c__bar + a__bar)]))

Vector(3, {(1) = 3*b*c__bar-Delta, (2) = -3*a__bar*b+Delta, (3) = b*(-c__bar+a__bar)})

(10)

t5[3]:=simplify(t5[3],sidrels)  ;#This should be b*b__bar

 

-a__bar^2+(2*b+d)*a__bar-Delta

(11)

t5

Vector(3, {(1) = 3*b*c__bar-Delta, (2) = -3*a__bar*b+Delta, (3) = -a__bar^2+(2*b+d)*a__bar-Delta})

(12)

subs(sidrels[-2],b*(-c__bar + a__bar))

b*(-c__bar+a__bar)

(13)

algsubs(sidrels[-2],b*(-c__bar + a__bar))

b*(-c__bar+a__bar)

(14)

 


 

Download 2026-07-29_Q_Simplifications_and_Substitutions.mw

In the attached file, I'd like to solve an ODE as an exercise. Only the "series" option yielded a solution. How can the length of the result series be controlled? Is there a package that leads to a "closed" solution – even using well-known transcendental functions?

restart

ode := (1+f(x))*(diff(f(x), x, x)) = 1+x

(1+f(x))*(diff(diff(f(x), x), x)) = 1+x

(1)

ics := f(0) = 1, (D(f))(0) = 0

f(0) = 1, (D(f))(0) = 0

(2)

dsolve({ics, ode}, f(x), series)

f(x) = series(1+(1/4)*x^2+(1/12)*x^3-(1/192)*x^4-(1/240)*x^5+O(x^6),x,6)

(3)

``

Download test.mw

Responses from the AI assistant in Maple2026 can be copied directly into a Maple Document or Worksheet, Is there a process which allows one to similarly import a external ChatGPT conversation. I have Maple MCP configured in my ChatGPT account.

How to integrate this function (n::posint) :
f := (n, x) -> (1 - cos(n*x))/(1 - cos(x))

Maple is not returning a result. It seems unable to establish the connection with the Dirichlet kernel. Is there a solution that doesn't require forcing a decomposition into a sum of cosinus?

Thank you for your help.

Best regards.

I am pretty new to pdsolve.

?pdsolve/numeric states

PDEsys - single or set or list of time-dependent partial differential equations in two independent variables

This could be interpreted in a way that problems with 3 independent variables can be handled (time + two others).

The rest of the helppage only describes two independent variables and does not mention time.

In case the above interpretation is wrong, I have two questions:

  • If only two independent variables can be treated, why is time-depencency mentioned at all?
  • Is it possible to integrate the PDE of an axially heated rod of finite length and radius with the help of pdsolve where on one end of the rod a heat flux q=q(r) is applied?

Any links to similar problems solved with Maple (not necessary with pdsolve) are very much appreciated.

Edit: Updated BCs

PDE := diff(T(r, z, t), t) = alpha*(diff(T(r, z, t), r, r)+(diff(T(r, z, t), r))/r+diff(T(r, z, t), z, z))

diff(T(r, z, t), t) = alpha*(diff(diff(T(r, z, t), r), r)+(diff(T(r, z, t), r))/r+diff(diff(T(r, z, t), z), z))

(1)

Updated BC

BC1 := -k*(D[2](T))(r, 0, t) = q; BC2 := (D[2](T))(r, L, t) = 0; BC3 := (D[1](T))(R, z, t) = 0; BC4 := (D[1](T))(0, z, t) = 0; IC := T(r, z, 0) = 0

T(r, z, 0) = 0

(2)

NULL

Corrected original BC (this is a different case of constant external temperature)

BC1 := -k*(D[2](T))(r, 0, t) = q; BC2 := T(r, L, t) = 0; BC3 := T(R, z, t) = 0; BC4 := (D[1](T))(0, z, t) = 0; IC := T(r, z, 0) = 0

T(r, z, 0) = 0

(3)

NULL

Download 2d_BVP.mw

1 2 3 4 5 6 Page 1 of 6