Hello Ladies and Gents,

Two more questions and I will be finished to bother you :)

What are the equivalent command for FromCharactersCode and ToCharactersCode ?

Is there a equivalent of Chop for Maple.

The first question answer might hide in some package.

Voilà.

I *shall* stop to ask questions between "math"ematica and Maple

From now on I will stick to Maple !

Thanks and kind regards to all of you.

Jean-Michel

Error, (in LinearAlgebra:-Modular:-IntegerLinearSolve) invalid arguments to iratrecon

I ran a procedure that uses only `solve/linear`. The above error was returned. Any ideas how to prevent it or why it happened?

How does `solve/linear` reach LinearAlgebra:-Modular:-IntegerLinearSolve?

Did you know that October 24th, 2026, is a very special day for us math lovers? Writing the date as 10/24/26, the date creates the following Pythagorean triple:

10² + 24² = 26²

Making it a Pythagorean Theorem Day! In fact, it is the very last one of the century (the next being in 2105). Over the years, our Maple community has been exploring some incredibly interesting ways of visualizing, proving, and applying one of math's most famous theorems!

To celebrate this great day, I thought we could revisit some of our coolest posts on the topic.

Since we are celebrating a pythagorean triple day, the Maple Learn post on Generating Pythagorean Triples is a great way to explore the theorem. Any three positive integers that satisfy the pythagorean formula are considered one of these triples (the most popular being 3, 4, and 5). The generation of these values can be looked at from both a geometric and algebraic perspective!

One of the coolest things about the Pythagorean Theorem is that we are still discovering new ways to prove it! Traditionally, a geometric method was used to prove the theorem, as can be seen in this Maple Learn post. But in only 2023 two high school students, Calcea Johnson and Ne'Kiya Jackson, presented a new trigonometric proof for the Pythagorean Theorem. 

This was incredible since most trigonometric proofs are based upon the theorem itself, so being able to prove it without these was very impressive! You can explore their approach in Johnson and Jackson's Proof of the Pythagorean Theorem, or read more about it in the MaplePrimes post New Proof of the Pythagorean Theorem.

This even inspired some mathematical artwork in Maplesoft's art competition, Paige Stone created an embroidery piece Infinite Similar Triangles based on the Johnson-Jackson triangle construction. What a fun reminder that math is just as creative as it is logical!

The Pythagorean Theorem is mostly thought of as a right triangle problem, but it is so much more than that!

Consider the Staircase Paradox. If you keep decreasing the size of steps to a staircase, the shape begins to look like a straight diagonal, but the length does not approach the length of that diagonal! The Pythagorean Theorem helped us uncover the surprising behavior behind these limits. 

Another interesting application is in Finding the Shortest Path Between Two Points, where the theorem can be applied to arc length calculations. This theorem can show up in some unexpected places! Below is an example of some curves the Pythagorean theorem can be used to calculate!

From geometry, to algebraic and trigonometric proofs, mathematical art or simply a good paradox, the Pythagorean Theorem can be explored endlessly. Do you have a favorite proof, application, or derivation from the Pythagorean Theorem? Try to appreciate it a little more on this day, since we won't have another for a while!

Can the Maple community make exact integrability computations substantially faster?

For a planar polynomial vector field
[
D=A(x,y)\partial_x+B(x,y)\partial_y,
]
a Darboux polynomial is a nonconstant polynomial (f) satisfying
[
D(f)=Kf
]
for a polynomial cofactor (K). These invariant algebraic curves are fundamental building blocks in the search for first integrals and integrating factors.

The subject reaches back to Darboux’s nineteenth-century work and connects with the Prelle–Singer and Singer theories of elementary and Liouvillian integrability. Turning these structural results into effective, reliable programs remains an important computational problem. Given Maple’s long tradition in symbolic differential equations, MaplePrimes seems an ideal place to invite a practical challenge.

The starting point

Bostan, Chèze, Cluzeau and Weil developed algorithms for bounded-degree rational first integrals and Darboux polynomials using local solutions and extactic constructions. Related ideas appear in Chèze–Combot’s algorithms for symbolic first integrals and Combot’s work on symbolic integration of planar differential foliations. These works include Maple implementations.

They provide powerful mathematical frameworks, but their implementations can encounter substantial practical difficulties:

• coefficient growth in exact truncated series;

• expression swell in parameter-dependent extactic matrices, polynomial minors and Smith-form computations;

• expensive matrix assembly, exact linear algebra and reconstruction.

The bottleneck depends on the input and the implementation. Improving the kernel solver alone may achieve little when exact series construction dominates.

Our current baseline

We have implemented practical optimizations within these frameworks: jet-based constructions, truncated-series arithmetic, avoidance of full Smith-form computation in the Darboux code, modular filtering and linear algebra, rational reconstruction, and exact verification.

These are our current best-performing implementations, offered as reproducible baselines for further improvement—not as a claim of universal optimality.

For Darboux polynomials:

restart:
read "PATH/TO/FastDarboux.mpl":

A := 1:
B := 4*x^3 + y - x^4 - 1:
N := 4:

R := FastDarboux:-All(A,B,N,x,y):
R[status];
R[curves];
R[rational_curves];

The records in rational_curves are pairs [f,K]. Algebraic coefficient extensions are represented in curves. The status "finite_complete" certifies complete finite enumeration within the stated scope; rational-first-integral and other exceptional cases have separate statuses.

A single-section calculation is available through:

R := FastDarboux:-Partial(A,B,N,0,x,y):

This searches using the section (x=0); its scope must not be confused with complete enumeration.

For the Liouvillian integrating-factor benchmark:

restart:
read "PATH/TO/Combot.mpl":
read "PATH/TO/slow_example.mpl":

st := time[real]():
R := IntegratingFactor(B/A,[-1,0],27):
time[real]() - st;

The benchmark file supplies (A,B). The implementation prints a completion status.

For this example, on our Maple 2026 test system, the complete call took about 123 seconds:

The returned integrating factor was independently verified by exact identities. These measurements describe one benchmark, not a general complexity claim.

Source code: Source code-Huang 
Documentation and mathematical scope: Documentation-Huang 
Benchmark inputs, environment and logs: Benchmark-Huang

The challenge

Improve end-to-end wall-clock time and memory use while preserving soundness and completeness for an explicitly stated bounded problem.

A better asymptotic bound is welcome, but it is not the primary objective. In exact symbolic computation, a field operation has no fixed machine cost: coefficient sizes, normalization, intermediate representations and data movement can outweigh an attractive exponent.

Technical improvements and well-designed heuristics are especially welcome. Possible directions include finite-field series construction, better precision management, adaptive reconstruction, structured linear algebra, improved candidate selection, or entirely different approaches.

Heuristics are welcome when their role is explicit: a failed heuristic must not silently become a proof of nonexistence. Likewise, verifying every returned curve proves soundness, but does not by itself prove completeness.

Please state degree bounds and assumptions, distinguish “no solution within the bound” from “inconclusive,” and handle rational-first-integral or infinite-family cases explicitly. This challenge does not assume that bounded searches settle unrestricted Liouvillian integrability. The current integrating-factor code also does not claim to return a minimal representation.

For performance comparisons, please include the whole computation, including preprocessing, series, reconstruction and certification, and compare tasks with the same mathematical scope.

AI tools have made remarkable progress in mathematical reasoning and programming. This is a concrete opportunity to use them on a longstanding computational problem. Contributions from anyone are welcome, with or without AI assistance: Maple code, compiled backends, mathematical arguments, counterexamples, profiling observations, or small improvements that make an important difference.

Please post suggestions, implementations, benchmarks and supporting arguments directly in the comments. The goal is a faster, reproducible and mathematically trustworthy solver.

Hello,

I already ask these questions but can't find the answers :

1) about Maple floats (i.e the equivalent command 

for $MaxNumber,$MinNumber, etc)

2) how to get the list of all Packages with their commands

3) the list of all commands of Maple

(for example 'transpose' appears in ...12 packages, but I only know in mathematics only one

'transpose' , i.e the transpose of a matrix)

Thank you very much and all the best,

Jean-Michel

Does Maple natively work while using a VPN? If not, where do I go to learn how to configure it so it will work using a VPN? In Maple 2025 and Maple 2026, Maple will soft-lock when when attempting to execute any worksheet or attempting to read any help section when using a VPN under the default configuration configuration of Maple. 

...like the following without AI assistance ? Looking for differentiable solutions! The solution is not to be found in the books by Aczel or Small: L(x)*L(y) = L(2*x*y + x + y). (I know the stressful solution from my notes - the ones made with pen and paper.)

Is there a way in Maple to categorize functional equations into specific classes (e.g., Cauchy type) - and thereby identify corresponding solution methods - much like how Maple handles the solving of ordinary differential equations?

Given the sequence L = [1,3,5,7,9,11,13,15,17,19],

how can I find a recurrence relation using only the values:

L[2] = 3, L[5] = 9, L[7] = 13, L[8] = 15, L[9] = 17, L[10] = 19 ?

For those who are familiar with the long history of the Maple Conference, you’ll know that we vary the format from time to time, and for the next conference, we'll be trying something new!

The next event will be a user conference, strongly focused on enabling Maple users to get the most out of Maple, increasing their knowledge and abilities through a series of technical talks by Maple experts. We’ll release more details later, but our main goal is to engage with and support the many customers who love Maple and want to learn how to do even more with it. This event will be held in the spring of 2027, which we hope will be a convenient time for those who find it difficult to attend a fall event.

Another aspect of past conferences has been the opportunity for users to share their work with the Maple community. We'd like to remind you that the Maple Transactions, an open-access online journal, is an ideal place to publish your work, and you can see an overview of the journal in this short video. If you prefer a less formal venue, we encourage you to post right here on MaplePrimes to share your work and interact with the community.

We will share more details as we get closer to the event. For now, we just wanted to give you an idea of the plans, as we know that many people look forward to the Maple Conference and expect to hear from us around this time.

While practicing with the "identify" command, I came across the question:

Does Maple offer a way to determine the generating rule for a sequence of numbers given by a finite initial segment?

Here is a riddle for this:

The sequences {s_n} = 1/1; 1/2; 1/3; ... and {t_n} = 0/1; 1/2; 2/3; 3/4; ... have the formation rules

s_n = 1/n and t_n = (n-1)/n.
What is the formation rule for the sequence {u_n} = {s_n; t_n} formed by alternating between the two?
Note: The solution is not u_2n = t_n and u_(2n−1) = s_n. Rather, the goal is to find a single, unified formation rule u_n that yields the terms of the combined sequence for n = 1; 2; 3; ...

How would one go about querying AI in Maple?

If I compare Maple 2024 and Maple 2022 on the exact same worksheet, Maple 2022 executes twice as fast as Maple 2024.

For my kind of work this is very serious. I have programs that can take 10 or more days to complete calcuations, therefore what Maple 2022 will calculate in 10 days, Maple 2024 takes 20 days. It has wasted a LOT of my time, whatever the reason is.

Here is the code: 
1) MM must be a high order series expansion with complex arguments so that simplification is not trivial. Use any such asymptotic expansion.
NOTE: I can supply an expansion for a developer through official Maple support, but cannot release it publicly as it is part of a future publication. It is easy enough for anyone to create a complex expansion, with difficult simplification.
2) The simplification of the expansion must at least take a couple of minutes at e.g. Order=10 for the comparison to make sense.
3) Then run the program for Maple 2022 and Maple 2024 respectively and note execution time.
4) This was run on Linux.

As you will see the Maple 2024 calculation takes twice as long as the Maple 2022 calculation. 
SEE RESULTS AT END OF PROGRAM.

testorder:=6;                             # Enter the expansion order here.
MM:=??:                                   # Enter the expansion here.
series(MM, x = 0, testorder):
convert(%, polynom):
map(simplify, %):
#collect(%, x, simplify):
simplify(%):

                        testorder := 6

RESULTS:

OPTION1 Calculation time for series MM,

Maple 2024
O(4):   Linux Wall-Clock Time: 1.000 seconds
O(6):   Linux Wall-Clock Time: 11.000 seconds
O(8):   Linux Wall-Clock Time: 153.000 seconds
O(10): Linux Wall-Clock Time: 2135.000 seconds 
O(12): Linux Wall-Clock Time:  19593.000 seconds

Maple 2022
O(4):   Linux Wall-Clock Time: 0.000 seconds
O(6):   Linux Wall-Clock Time: 9.000 seconds
O(8):   Linux Wall-Clock Time: 88.000 seconds
O(10): Linux Wall-Clock Time: 1062.000 seconds 
O(12): Linux Wall-Clock Time: 8987.000 seconds

I tried to copy a snippet of a maple command from a worksheet and paste it elsewhere in the worksheet and it was transformed into document form. I could not figure out how to fix that.It was worthless to me. For example, in the command I had "eval(f, [y=1,d=3])" and it became f| with the subscript y=1,d=3.

Also, I wrote "parametr" in a procedure and Maple rejected the command with a vague complaint. OK, my bad; garbage in garbage out, parameter not parametr, etc. BUT this is 2026! Autocorrect features have been around for years. Underlining of strange spellings are standard on word processors, phones , etc. Can't Maple catch up? 

With thanks for the advice regarding quadratic Diophantine equations and tabulation, here is a little puzzle:
For a rectangular cuboid, the length of the space diagonal is known to be 90 cm and its surface area 8800 cm². Determine its integer edge lengths.

Is Maple 2026 compatible with Mac OS27.1 ___________________________________________________________

In the attached file, I would like to create a table of values ​​(k,f(k),g(k)) for the functions f and g for, e.g., k=1..10. I would appreciate your help with this, as f and g refer to reciprocity in their expressions.

test.mw