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.
 

Download 2026-07-29_Q_Simplifications_and_Substitutions.mw

I am a long-time user of Joe Riel's maplev mode in emacs. Upgraded emacs to version 30.2 and now it does not work anymore because of difficulties with something called abbrevlist. This is on MacOS. I am already on the last version of maplev.

Anyone have an idea what is going on and what to do? Somehow for me referencing a username no longer is possible (I get a blocking box with a spinner upon entering the at sign) so I can't create a notification for Joe.

TIA,

Mac Dude.

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?

Download test.mw

Download IntegerEigenvalues.mw

This piecewise function with units

q := r -> piecewise(0 <= r and r < 0.1*Unit('mm'), 5*Unit(('kW')/'m'^2));

returns this output

Is it possible to get the output printed without ticks and the units in roman?

In the attached file, I would like to calculate the expressions for the function f(n,x) using a recursion for a given index range, e.g., n=3..15. I would appreciate any advice on this.
 

Download test24c.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.

So the problem I encountered is when I try to assign ranking of variables of ODE in ThomasDecomposition, the indexed variables are not allowed. For instance, for an ODE system containing a[0], a[1], a[2] as dependent variables, if I assign:
R := Ranking([x],[a[0],a[1],a[2]])
It throws an error:
This is going to be inconvenient when I have to dynamically solve ODE system within a function call, especially when the system is nonlinear and algebraically closed(no integration constants in solutions) and calling DifferentialThomas in dsolve will be slow. I want to know how to resolve this.

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.

In the context of numerical integration of partial differential equations I am looking for tools to create difference equations for the numerical integration of PDE's. Ideally the desired integration scheme could be given as an input.

The only command that I am aware of is the DiffEquation command from the DynamicSystems package (see ?DynamicSystems,DiffEquation) which is limited to linear time invariant systems and only provides a simple forward integration scheme.

Any insights/examples into the topic of numerical integration of pde's with Maple beyond pdsolve/numeric capabilites is very much appreciated. (I know that Maple comes with advanced numerical solvers for ODE's. MapleSim uses such solvers to integrate systems of ODE's. This seems to be, in terms of computation, close to what I am looking for.)

Today is Pi approximation day (22/7) and I will use that as an excuse to share my new favourite expression for Pi:

And this isn't even an approximation! Recently, continuous mathematics has found its own equivalent to the digital hardware NAND gate. In his paper “All elementary functions from a single binary operator”, Andrzej Odrzywołek demonstrated that a single functional primitive can generate the entire standard continuous spectrum of operations. In other words, every single button on a scientific calculator, from addition and subtraction to sines, cosines, and logarithms, can be built using just this one function.

This Maple Worksheet explores how the 'Exp-Minus-Log' ("EML") operator, when paired solely with the constant 1, can be systematically nested to construct basic arithmetic, constants, and complex transcendental functions within Maple.

In essence, he discovered that the binary operator EML, along with the constant 1, forms a basis for the set of standard scientific-calculator operations.

This means that functions like ,  and operations like  or  can be creating by composing EML with itself in clever ways. Some constants and functions are trivial to represent, such as EML(1,1) = e or EML(x, 1) = exp(x), others however, are not...

With a quick one-command tweak, you can get Maple to use the property of the extended reals that

And then with a simple argument about standard branches, you can construct the natural logarithm for real numbers, which immediately leads the constant zero:

You can then expand the tools in your toolbox by creating subtraction with EML, ln(x), and exp(x)

Which then expands the toolbox further by allowing for the construction unary minus from the constant 0 (since -x = 0 - x), and then addition (since a+b=a-(-b))

Since we've constructed addition, subtraction, zero and one, we can technically construct every integer! It would not be very pleasant, and by no means optimal... but you could! Here's 7 for example:

The next step to building all the standard functions is multiplication and inversion. And these use the classic trick by using the fact that x=exp(ln(x)) can help simplify:

These are compositions of exp, addition, ln, and unary minus (all functions constructed previously), which means they can be made with only EML:

It's at this point that I will leave the derivation of division (a/b) and exponentiation (a^b) as exercises for the reader, so I can skip to something a little more complex...

To go beyond the basic operators, you'll need to step into the complex domain by constructing the imaginary constant i. To do this, take ln(-1) = -i*Pi (by using the standard branch) and combine it with Euler's formula

And once again the expression on the left-hand side is made up of operations that were all previously defined, so you can compose EML to get a new constant:

And finally, it's possible to break down the expression for Pi from the start, since it's the product i*ln(-1)

By successfully extracting the mathematical constants i and Pi, I think this demonstrates the complete constructive capability of the EML operator in the complex domain. While the resulting syntax trees become exponentially deep and unoptimized for human readability, they prove that continuous operations do not require a massive, distinct toolbox. Future applications of this uniform binary structure could dramatically simplify symbolic regression and machine learning optimization models. 
Ultimately, the EML operator reveals the remarkable truth that the vast complexity of scientific mathematics can be distilled down to a single, beautiful building block.

Isn't math awesome?

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

Download 2d_BVP.mw

Hello,

I want to define these two equations.I know how I can define a Tensor, but how can I use a Tensor with tue diffrent indices. In one case I need u[i] , but I need also u[j]. I know also, that I need an extra command if I want to use latine letters. Can somebody write this complete for me ?

Thank you 

Hello,

I was wondering whether there is a way to achieve the same result as the code below, but using threads instead of Grid.

The problem is the following. Given a very large list of models (the example below contains only two models), I would like to return a set of sets using a simpler notation for the alpha parameters.

Example

models:=[[y^2*z*alpha[1, 17], z^3*alpha[2, 19], x*z^2*alpha[3, 15] + z^3*alpha[3, 19]], [y^2*z*alpha[1, 17], z^3*alpha[2, 19], x*z^2*alpha[3, 15] + y*z^2*alpha[3, 18]]]:

Desired output

{{[1, 17], [2, 19], [3, 15], [3, 18]}, {[1, 17], [2, 19], [3, 15], [3, 19]}}

The order of the elements does not matter, but the final result should be a set of sets.

The code I am currently using is

svars:={x,y,z}:
Grid:-Set('svars'):
convert(Grid:-Map(w->map(v->[op](v),indets(w,name) minus svars),models),set)

Unfortunately, indets is not listed as thread-safe, so I cannot simply replace Grid:-Map with Threads:-Map.

Is there a thread-safe alternative (or a completely new way of doing the same thing) that would achieve the same result?

Many thanks.