Categories

Gabriel’s Horn is one of the most famous examples in calculus of how infinity can behave in ways that completely defy our intuition.

The horn-shaped object is created from a very simple curve: y = 1/x for x ≥ 1 (pictured below).

Now imagine rotating this curve around the x-axis. The resulting surface stretches infinitely far to the right while becoming thinner and thinner. Visually, it resembles a long trumpet or horn that continuously narrows to a thickness of zero.

At first glance, nothing about this shape seems particularly mysterious. As x grows larger, the radius 1/x becomes smaller and smaller. It seems reasonable that both the volume contained inside the horn and the area of its surface would remain finite (or at least if the volume was finite, then the surface area would also be finite). After all, the horn gets extremely thin very quickly.

Calculus allows us to test that intuition.

To compute the volume of the horn, we use the disk method. Each slice perpendicular to the x-axis forms a circular disk of radius r = 1/x, each with an area of π*r² = π*(1/x²).

The total volume is the sum of an infinite number of these disc areas with thickness dx. As an integral,

V = π ∫₁^∞ (1/x²) dx.

This is a simple integral that converges to a value of 1. We could use the power or rule or our favourite computing software (I used Maple below).

Hence, V = π ∫₁^∞ 1/x² dx = π*1 = π. This means the horn contains only π cubic units of space, even though it extends infinitely far. 

Now let’s compute the surface area of the horn. For a surface of revolution, the surface area is

A = 2π ∫₁^∞ y √(1 + (y′)²) dx.

Since y = 1/x, we have y′ = −1/x². Substituting into the formula gives

A = 2π ∫₁^∞ (1/x) √(1 + 1/x⁴) dx.

Software like Maple can easily handle this integral. It tells us the integral diverges to infinity.

However, this is difficult to solve analytically. To understand what happens to this integral, notice that for large x, the square root term is very close to 1, since 1/x⁴ can be approximated as 0 as x grows large. This means the integrand behaves roughly like 1/x (it's actually slightly larger than 1/x). But

∫₁^∞ 1/x dx diverges, and ∫₁^∞ (1/x) √(1 + 1/x⁴) dx > ∫₁^∞ 1/x dx, so ∫₁^∞ (1/x) √(1 + 1/x⁴) dx must also diverge. As a result, the surface area of Gabriel’s Horn is infinite.

This leads to the famous, surprising conclusion:

• The horn has finite volume.
• The horn has infinite surface area.

In other words, it could be filled with a finite amount of paint, but it would require an infinite amount of paint to coat its inside surface.

Of course, real paint has thickness, so the paradox disappears in the physical world. Eventually, the horn would become thinner than the paint layer itself. But mathematically, the result is perfectly consistent.

The key idea lies in how quickly the function 1/x shrinks. The cross-sectional area of the disks scales like (1/x)² = 1/x², and the integral of 1/x² converges.

But the circumference of each slice scales like 1/x, and the integral of 1/x diverges.

So as the horn extends outward, the added volume decreases quickly enough to sum to a finite value, while the added surface area decreases too slowly and accumulates forever.

Gabriel’s Horn beautifully illustrates one of the central themes of calculus: infinite processes can produce results that feel deeply counterintuitive.

Volume and surface area seem closely related, but can behave in completely different ways when infinite limits are involved. A shape can stretch endlessly yet still contain a finite amount of space.

This strange object reminds me that mathematics isn’t just about calculating numbers, but is also about exploring the strange and fascinating consequences of simple ideas pushed to their limits.

I was wondering whether a water molecule exhibits the intermediate axis theorem (IAT) effect.

I was also curious if a tool like MapleSim could be used for simulations, as it is designed with technical applications in mind. (It would have been handy to enter parameters in Angstroms and atomic mass, but MapleSim only provides length in mm and mass in grams for small objects.)  

The atoms of the H2O molecule form an obtuse triangle. An obtuse triangle exhibits the effect when rotated about its intermediate axis (horizontal axis in the image below) provided it consists of equal point masses (more details here) which is not the case for oxygen and hydrogen. 

Building and running a model is quick since geometry and masses are available online. Two molecules are modeled in the attached file with parameters from different sources. The left model in the image below represents the atoms as three discrete point masses without individual rotational inertia. The system's total inertia is derived entirely from the spatial distribution of these masses. On the right, the entire molecule is modeled as a single lumped mass located at the center of mass (CoM), with the molecule’s full rotational inertia tensor applied at that point.

IAT_H2O.msim

Both models are rotating about the assumed intermediate axis at 3 THz (3 trillion rotations per second), which is about two orders of magnitude less than near-infrared light (just beyond the visible spectrum). To generate the IAT effect an orthogonal tiny initial “kick” of 0.001 Hz was added.

Visualizing was not so easy since the models are in the picometer range. It was difficult to locate the molecules by zooming with the mouse wheel (the button “Fit scene” on the 3-D Playback window did not work). Running an animation to visualize the IAT effect was not possible because the display speed could “only” be slowed down by a factor of 2^31 (see A in the image below). However, the slider C to move back and forth in time worked. The time (B) was always rounded to zero due to the very short simulation time span of 1E-10 seconds (i.e. 10 picoseconds).

Export of an animation movie worked better. Over the displayed timespan of 10 ps the molecules flip 2 times back and forth. This corresponds to a flip frequency of 200 GHz.

Time is still not displayed in the movie but that is pretty much all what did not work. Overall, a good performance. Also the numerical results did not show signs of loss of fidelity despite the atomic scale  of the objects and the very short time span.

In reality, the rotation of a dipole results in the emission of electromagnetic radiation, which dissipates energy and decelerates the molecule. How can this damping effect be modeled in MapleSim? Someone has an idea?

For decades, Maple has been built around one of the world’s most powerful mathematics engines—helping students, educators, engineers, and researchers explore ideas, solve complex problems, and communicate mathematics clearly.

Maple 2026 builds on that foundation with major advances in the math engine, expanding the kinds of problems Maple can solve while improving reliability and performance.

At the same time, Maple 2026 introduces new AI-powered tools that help you work faster—finding commands, generating visualizations, explaining concepts, and helping you explore ideas. The key difference is that these tools sit on top of Maple’s math engine, so the results are grounded in real computation rather than guesswork.

If you’ve been following along with our recent Mathy teaser videos and sneak peek posts, you may already have seen hints of some of these features. Now I’m excited to finally share them in full.

One of the most exciting additions in Maple 2026 is the new AI Assistant.

AI tools are incredibly useful for exploring ideas, writing code, and learning new topics. But when the mathematics becomes more involved, relying on AI alone can be risky. The Maple AI Assistant brings those productivity benefits into Maple while keeping the mathematics grounded in Maple’s trusted computation engine.

You can ask the AI Assistant questions in natural language and have it help you:

• find Maple commands or formulas
• generate Maple code
• create visualizations
• explain mathematical concepts
• draft examples, worksheets, or reports

Because Maple performs the underlying computations where appropriate, the results are grounded in Maple’s powerful math engine. The AI Assistant becomes a productivity partner that helps you accomplish tasks in Maple faster and more easily, combining the flexibility of AI with mathematics you can trust.

Watch the AI Assistant in action.

Another feature I’m particularly excited about is Document Import.

Many of us have years of mathematical content stored in PDFs, lecture notes, journal articles, slides, or even handwritten pages. Traditionally these documents are static—you can read them, but you can’t interact with the mathematics inside them.

With Maple 2026, that changes.

Document Import allows Maple to convert many document formats—including PDFs, DOCX files, and presentations—into Maple worksheets where the mathematics becomes live and executable. 

The image below illustrates the transformation.

On the left (“Before”), scribbled handwritten notes from a Calculus III lecture were saved in a Word document. The notes include hand-drawn sketches, formulas, and written explanations.

After importing the document into Maple (“After”), the mathematical expressions were recognized and converted into live, editable Maple mathematics. The text was preserved, and the hand-drawn sketches were retained as images. The resulting worksheet supports evaluation, editing, and further computation.

Once imported, you can:

• evaluate expressions
• modify formulas
• extend derivations
• add visualizations
• explore variations of the mathematics

Instead of recreating examples from scratch, you can bring existing material directly into Maple and start exploring.

While the new AI features are exciting, the heart of Maple has always been its mathematics engine—and Maple 2026 delivers significant advances here.

One particularly notable improvement is Maple’s expanded ability to solve linear recurrence equations. Through improvements to the rsolve command and major extensions to the LREtools package, Maple can now solve dramatically more recurrence relations than before, including many third- and fourth-order cases that were previously beyond reach.

In fact, Maple can now fully solve over 94% of the 55,979 entries in the Online Encyclopedia of Integer Sequences (OEIS) that that can be shown to satisfy a linear recurrence relation. These advances reflect ongoing research into linear difference equations and their algorithmic implementation in Maple, continuing Maple’s long tradition of advancing the state of computer algebra.

Beyond recurrence solving, Maple 2026 includes many improvements across its core symbolic and numeric algorithms. Maple’s assumption system has been strengthened to improve reasoning under mathematical assumptions, and enhancements to the simplify, combine, and evalc commands allow Maple to produce more compact and mathematically natural forms for a wider range of expressions.

There are also improvements to Maple’s differential equation solvers, polynomial system solving, and numerical solving routines such as fsolve, along with updates to other foundational parts of the math library used throughout the system.

Taken together, these improvements expand the range of problems Maple can solve and improve the robustness, correctness, and efficiency of the results.

Maple has always offered extensive control over plotting options, but achieving consistent visual styling across multiple plots could require specifying many settings each time.

Maple 2026 introduces Plotting Themes, which allow you to define a plotting style once and apply it across many plots with a single option.

Themes make it easy to maintain consistent visual styles in worksheets, teaching materials, reports, and publications, while still allowing individual plots to override specific options when needed.

The image below shows an example of creating and applying a custom plotting theme. 

Maple continues to be widely used in classrooms around the world, and Maple 2026 includes several improvements designed to support teaching and learning.

The Check My Work system has been enhanced so Maple can recognize a wider variety of valid student solution steps and provide more accurate feedback.

Maple 2026 also improves the generation of similar practice problems, making it easier to create variations of a problem while preserving its mathematical structure.

In addition, Maple’s step-by-step solutions have been expanded to support more types of expressions, helping students better understand the reasoning behind the mathematics they’re learning.

Maple 2026 also introduces improvements for developers building advanced applications, along with performance enhancements across the system.

One particularly interesting addition is the new VectorSearch package, which implements a vector database directly inside Maple.

If you’re not familiar with vector databases, one way to think about them is through recommendation systems like Netflix or Spotify. Each movie or song can be represented by a vector containing thousands of numbers describing its characteristics—things like genre, pacing, or mood. When you watch something, the system finds other items whose vectors are closest to it, which is how recommendations are generated.

With the new VectorSearch package, Maple can store thousands (or more) of vectors and efficiently find the ones most similar to a given vector. This makes it easier to build applications involving machine learning, data analysis, and modern AI workflows directly in Maple.

Maple 2026 also delivers significant performance improvements. For example, operations involving quantities with units have been greatly optimized—some computations now run over 90 times faster, making Maple even more efficient for engineering and scientific workflows.

Maple 2026 also expands the benefits available through the Maplesoft Elite Maintenance Program (EMP). The new benefits include access to additional Maplesoft products and services:

• Maple Learn, the online environment for teaching and learning mathematics
• Maple Calculator Premium, bringing the power of Maple to your phone with full access to features like Solution Steps and Check My Work
• Maple MCP, which allows you to connect Maple’s math engine to external AI tools so they can produce mathematical results you can trust

These additions extend Maple beyond the desktop, giving users powerful tools for learning, teaching, and exploring mathematics across web and mobile platforms, as well as through integrations with external AI tools.

This post only scratches the surface of what’s new in Maple 2026. There are many more improvements across the math library, programming tools, and performance.

To learn more about all the new features and enhancements in Maple 2026, visit the What’s New in Maple page on our website.

I am very pleased to announce that Volume 6 Number 1 of Maple Transactions has been published.  This is a Special Issue on Matrices and Polynomials in Computer Algebra, and the Guest Editors (our first ever!) were Marc Moreno Maza and Tomas Recio.  There are still some papers that are expected to be added to the issue when they come in, but at this moment there are 8 papers there for you to read (and a description of the issue in the Front Matter section, by the Guest Editors).

A link to this Special Issue

This post was inspired by the following discussion thread  https://mapleprimes.com/questions/242266-Count-The-Number-Of-Paths , which considered the problem of finding all Hamiltonian paths on an integer lattice in R^2 that connect two distinct vertices. The  AllPaths  procedure solves a more general problem: it finds all self-disjoint paths connecting two distinct vertices not only in the plane  R^2  but also in space  R^3 . Of course, it also finds all Hamiltonian paths or allows one to determine their absence. The procedure does not use commands from GraphTheory package (only direct manipulation of sets and lists).
Required parameters of the procedure: S  is a set or list of lattice vertices specified by their coordinates, Start and Finish are the initial and final vertices. Optional parameter R (defaults it's NULL  if all paths are searched) and any symbol (if only Hamiltonian paths are searched). S can be either a rectangular integer lattice or a union of several such lattices.

Code of the procedure:

restart;
AllPaths:=proc(S::{set(list),listlist},Start::list,Finish::list,R::symbol:=NULL)
local N:=nops(S), S1:=convert(S, set), L, n, m, k, i, j, s, p, q, P, a, b, c;

L:={[Start]};
for n from 2 to N do

if R=NULL then

P:='P';
m:=nops(L);
for k from 1 to m do
if nops(Start)=2 then
i,j:=L[k][-1][];
s:={[i-1,j],[i,j+1],[i+1,j],[i,j-1]} else
a,b,c:=L[k][-1][];
s:={[a-1,b,c],[a,b+1,c],[a+1,b,c],[a,b-1,c],[a,b,c-1],[a,b,c+1]} fi; 
s:=`intersect`(s,S1) minus convert(L[k],set);
if s={} and L[k][-1]=Finish then P[k]:=L[k] else
if s={} and L[k][-1]<>Finish then P[k]:=NULL else
P[k]:=`if`(L[k][-1]=Finish,L[k],seq([L[k][],s[i]],i=1..nops(s)))  fi; fi;
od;
L:=convert(P,set) else

P:='P';
m:=nops(L);
for k from 1 to m do
if nops(Start)=2 then
i,j:=L[k][-1][];
s:={[i-1,j],[i,j+1],[i+1,j],[i,j-1]} else
a,b,c:=L[k][-1][];
s:={[a-1,b,c],[a,b+1,c],[a+1,b,c],[a,b-1,c],[a,b,c-1],[a,b,c+1]} fi;
s:=`intersect`(s,S1) minus convert(L[k],set);
if n<N then 
if s={} or L[k][-1]=Finish then P[k]:=NULL else
P[k]:=seq([L[k][],s[i]],i=1..nops(s)); fi else 
if L[k][-1]=Finish and s<>{} then P[k]:=NULL else P[k]:=seq([L[k][],s[i]],i=1..nops(s));
fi; fi;  
od;
L:=convert(P,set)

fi; od;

L;
end proc:

Examples of use.

In the first example from the post above, we find the number of Hamiltonian paths in 

L:=CodeTools:-Usage(AllPaths({seq(seq([i,j], i=1..11), j=1..3)}, [2,2], [10,2], 'H')):
nops(L);

In this same example, we find the number of all paths from A to B and the possible lengths of these paths.

L:=CodeTools:-Usage(AllPaths({seq(seq([i,j], i=1..11), j=1..3)}, [2,2], [10,2])):
nops(L);
map(t->nops(t), L);
L1:=select(t->nops(t)=%[-1], L):
nops(L1);

In the following example, we find the number of all paths, as well as the number of Hamiltonian paths, and animate these paths (total 24 one's).

S:={seq(seq([i,j],i=1..5),j=1..3)} union {seq(seq([i,j],i=4..7),j=3..5)}: A:=[1,1]: B:=[7,5]:
P:=plots:-display(plots:-pointplot(S, symbol=solidcircle, color=blue, symbolsize=15, view=[0..7.5,0..6.5], size=[600,500], scaling=constrained), plots:-textplot([[A[],"A"],[B[],"B"]], font=[times,bold,22], align=[left,above])):
L:=AllPaths(S,A,B):
nops(L);
map(t->nops(t), L);
L1:=select(t->nops(t)=%[-1], L):
nops(L1);
plots:-animate((plots:-display)@(plottools:-curve),[L1[round(a)], color=red, thickness=4], a=1..%, frames=180, background=P, size=[700,500], paraminfo=false);

In the final example, we search for Hamiltonian paths in a lattice defined on the surface of a cube. Imagine a cube made of wires, and an ant must crawl along these wires from point  A(0,0,0)  to point B(2,2,2) , visiting all nodes of this lattice. Is this possible? We see that it is not. The length of the maximum path is 25, and this lattice has 26 vertices. An animation of one of the maximum paths is provided.

S:={seq(seq(seq([i,j,k],i=0..2),j=0..2),k=0..2)} minus {[1,1,1]}: A:=[0,0,0]: B:=[2,2,2]:
P:=plots:-display(plots:-pointplot3d(S, symbol=solidcircle, color=blue, symbolsize=20, scaling=constrained), plots:-textplot3d([[A[],"A"],[B[],"B"]], font=[times,bold,22], align=[left,above]), plottools:-curve([[2,0,1],[2,2,1],[0,2,1],[0,0,1],[2,0,1]], color=black,thickness=0),plottools:-curve([[1,0,2],[1,0,0],[1,2,0],[1,2,2],[1,0,2]], color=black, thickness=0),plottools:-curve([[2,1,0],[0,1,0],[0,1,2],[2,1,2],[2,1,0]], color=black,thickness=0), tickmarks=[3,3,3]):
L:=AllPaths(S,A,B):
nops(L);
map(t->nops(t), L);
L1:=select(t->nops(t)=%[-1], L):
nops(L1);
plots:-animate((plots:-display)@(plottools:-curve),[L1[-1][1..round(a)], color=red, thickness=4], a=1..25, frames=240, background=P, paraminfo=false, axes=box, labels=[x,y,z]);

We can see from this animation that the path does not pass through the vertex (0, 2, 2) .

Edit. A code error that could cause incorrect operation when using the  R  option has been fixed. Everything now works correctly. If there is no Hamiltonian path passing through all vertices, the procedure returns the empty set { } .

Paths1.mw

This system of nonlinear equations was proposed by an artificial intelligence named Alice.

f1 := x4^3+x5^2*x6-sin(x3)+exp(x1*x2)-5; 
f2 := ln(x4+x5)-x6^2+x3^3-x1^2*x2-2; 
f3 := cos(x4*x5)+x6*sin(x3)-x1*x2^2+x4^2*x5^3;

At the same time, AI accompanied it with comments. Here are some of them:
 

### System Characteristics
 **Underdetermination**: 6 unknowns with 3 equations 

### Solution Complexity

* Lack of a general analytical solution
* Need to use numerical methods
* Possibility of multiple solutions
* Complexity of visualization
* Sensitivity to initial approximations

### Solution Methods

* **Iterative methods**:
* Newton's method
* Simple iteration method
* Gradient methods
* **Numerical methods**:
* Finite difference method
* Monte Carlo method
* Genetic algorithms
* **Optimization approaches**:
* Lagrange multiplier method
* Constrained optimization methods

### Practical Application

Similar systems are found in:
* Quantum mechanics
* Field theory
* Economic modeling
* Bioinformatics
* Machine learning
* Engineering calculations of complex systems

Analyzing such systems often requires specialized software and powerful computing resources.

Although the worksheets provided here have been developed under Maple 2015, they should work correctly with newer versions, except perhaps for commands that use the 'op' function ('piecewise' mainly).

In the sequel the acronym 'pdf' stands for 'probability density function'.


CONTEXT

This post originates from a recent question by @JoyDivisionMan and the ensuing discussion. 

In a few words, the OP noticed Maple 2025 failed to return a result and asked why. In his reply, @acer identified a code regression somewhere in between Maple 2023 and Maple 2025.
Like Maple 2023 "my"  Maple 2015 does not fail but provide... a wrong answer: Do versions in between 2015 and 2024 return wrong results too?
 

In this post I explain how we can calculate the result by hand (only elementary maths required), why Maple 2015 (and likely newer versions) returns an incorrect result, why Maple generally fails in returning a result, and finally provide several examples to illustrate that even mathematically simple.
The various test cases I present are all equally simple for a skilled human agent, but conversely all beyond the reach of Statistics:-PDF.
This raises the question: Can a robust algorithm for calculating this PDF be developed without resorting to an expert system (I don't like the term AI) that mimics human reasoning?


THE MAIN OBSERVATION

Let X some continuous univariate random variable (CURV) and 𝟇 a real valued function from defined over the support of  . Let Y the random variable defined by Y =  𝟇(X).

The main observation about Statistics:-PDF is that unless very specific situations, this procedure does not build the correct expression of pdf(Y) as soon as 𝟇 is not a strictly monotone function

Here are a fex exceptions to this claim:

X any CURV , 𝟇 : x ⟼ xⁿ  , n positive integer (correct solution even if 𝟇 is not monotone)

X ~ Uniform(-1, 1) , 𝟇 : x ⟼ arctanh(x)  (no result returned even if 𝟇 is strictly monotone).

It is worth saying that, only by chance, Statistics:-PDF may sometimes return the correct result even if 𝟇 is a non monotone function.
For instance, in @JoyDivisionMan's question, the procedure was indeed capable to provide a correct result for the case X ~ Uniform(0, 2𝜋) , 𝟇 : x ⟼ arctanh(x) but this was only because two errors balanced each other out. Replace X ~ Uniform(0, 2𝜋)  by X ~ Uniform(a, a+2𝜋) and Maple is wrong (notice that the pdf of 𝟇(X) remains unchanged whatever the value of a).


A GOOD DRAWING WORTH A THOUSAND WORDS

Here is a picture to help understand how to get the pdf of Y =  𝟇(X) for a non monotone function 𝟇 (the case of a monotone function directly comes from this latter).

In this illustration X ~ Uniform(0, 2𝜋) , 𝟇 : x ⟼ sine(x).
To ease the explanation, I write X as a mixture of three uniform random variables X₁, X₂, X₃, whose supports are the intervals of the three branches of 𝟇. More formally, X  = (1/4)∙X₁ + (1/2)∙X₂ + (1/4)∙X₃.
The restrictions  of 𝟇 to these three branches are denoted 𝟇₁, 𝟇₂, 𝟇₃.

The large rectangles below the horizontal axis represent the pdf of X₁, X₂, X₃  and the blue curve the 𝟇 function.
The image of the interval [y-dy, y+dy]  by the inverse functions 𝟇₁^(-1) and 𝟇₂^(-1) of 𝟇₁ and 𝟇₂  are represented by the vertical rectangles [x₁-dy, x₁+dy] and [x₂-dy, x₂+dy] .
These two intervals bring a contribution to the pdf of Y (light gray blue on the right) represented by the horizontal violet rectangle on the right side of the picture.

The probability Prob(Y ∊ [y-dy, y+dy]) that Y belongs to the interval [y-dy, y+dy]) is simply the sum 
                 Prob(Y ∊ [y-dy, y+dy])  = Prob(X₁ ∊ 𝟇₁^(-1)([y-dy, y+dy]))  + Prob(X₂ ∊ 𝟇₂^(-1)([y-dy, y+dy]))

Let 𝟇'_b^(-1)(y) denote the derivative of 𝟇_b^(-1)(y).
Making dy tends to 0 gives
                pdf(Y = y)  =  pdf(X₁ = 𝟇₁^(-1)(y)) ×  | 𝟇'₁^(-1)(y) | + pdf(X₂ = 𝟇₂^(-1)(y)) ×  | 𝟇_'2^(-1)(y) |

As I said before there is truly no big math behind this, Except maybe those absolute values?
To understand where they come from zoom in on the rectangle 𝜔 = [x₁-dx, x₁+dx] ╳ [y-dy, y+dy] and denote X_𝜔 and Y_𝜔 the restrictions of X₁ and Y to 𝜔.
Locally Y_𝜔 is proportional to A+B∙X_𝜔 where constant B = 𝟇'(x₁) and the value of constant A does not matter here.
So the pdf of Y_𝜔 is (a classical result)  pdf(Y_𝜔 = y) = pdf(X_𝜔 = (y-A)/C) / |C|.
Few details can be found Here.


MAPLE FAILURES AND WEAKNESSES

So why did Maple, at last some versions, produce a wrong result and why some versions are not even capable to return one?
The reason is that there is no big math only at first sight...because determining the inverse function of 𝟇 can be quite tricky as soon as 𝟇 is not one-to-one map, for instance when 𝟇 is not strictly monotone.
When it is so 𝟇^(-1) must be defined for all the branches whose definition intervals intersect the support of X.

I spent a lot of time debugging the procedure Statistics:-PDF to understand why it either fails or produces incorrec results.
The sine_debug_nodebugoutput.mw  worksheet presents the "X ~ Uniform(0, 2𝜋) , 𝟇 : x ⟼ sine(x)" case (as Mapleprimes stubbornly refuses to upload the worksheet containing the debugger trace, I convert it to sine_debug.pdf to help you see this trace). 
To orient the core development team correcting this procedure (assumming they care), the critical procedures are

Statistics:-RandomVariables:-PDF:-Univariate:-GetValueTab[anything]
and  Statistics:-RandomVariables:-GetInverse
 

At the very end it is this second procedure which is truly responsible of Maple failing to provide a result or returning an incorrect on, because it does not correctly build the inverse functions 𝟇_b^(-1)  for all the branches b which matter.
 

I wrote above that "it is only by chance that Maple provided the correct result for the non monotone function 𝟇 = cosine". Indeed Statistics:-PDF returns a wrong result when X ~ Uniform(z, z+2𝜋) and z is not a multiple of 𝜋/2 (see cosine.mw).

Other important situations where Maple fails returning a result are those where 𝟇 is a polynomial function with different zeros located in the support of X.
I did not trace them but it seems that Statistics:-PDF does not know how to build the 𝟇_b^(-1) in this case (even though it is quite simple, see "Polynomial" examples below).


A SELECTION OF EXAMPLES

Here is a selection of examples to demonstrate that even in rather complex cases the pdfs of 𝟇(X) can be constructed quite easily (note that Maple either fails to compute them or to provide a correct result):

• Three examples where X is a uniform random variable and the restriction of 𝟇 to the support of X is a non monotone polynomial function of increasing degree (the number of branches to consider is equal to the degree of 𝟇):
  Polynomial_function_of_a_random_variable_1.mw,
  Polynomial_function_of_a_random_variable_2.mw,
  Polynomial_function_of_a_random_variable_3.mw
   
• Two examples where the support o  X is unbounded examples and 𝟇 = sine. Here an infinity number of branches must be accounted for, one of these two examples (X ~ Exponential) can be treated in a comple analytic way while the other (X ~ Normal) cannot thus leading to a truncated approximation of 𝟇(X) pdf.
  Infinte_support_sine.mw

OPEN QUESTION

Tracing Statistics:-PDF reveals an already complex algorithm designed to handle a broad variety of "canonical" situations. Even this the algorithm fails in almost all non-toy-problem such as this compilation proves Maple_failures.mw.
At first sight, there seems to be a contradiction between the (apparent?) simplicity with which one can obtain, by hand in sometimes in an ad hoc way, the expression of pdf(𝟇(X)), whether it is exact or truncated, and the complexity of the Statistics:-PDF algorithm, which results in failure in all non trivial cases.

This observation leads to the important question "Is it possible to rewrite Statistics:-PDF in order to enlarge its domain of success?".
I have the feeling that this means designing an algorithm which focuses more on mimicing the human reasoning than identifying "canonical" situations (as it is done today). 
An AI-driven algorithm maybe?

I repeat here that the maths are very simple, and all the more simple if you represent the random variable X as a mixture of components X₁, ... X_B, both having the same (truncated) distribution than X, and whose supports identify to the intervals of definition of the B branches of 𝟇 over the whole support of X.
The only difficulty lies in the identification of these branches and in the construction of the functions 𝟇_b^(-1) over the supports of each X_b.

I have no answer to this question.

In mathematics, us humans love to rely on intuition. It helps us make physical sense of phenomena and guide our thinking before formal reasoning is developed.

For example, approximating the derivative of a function at a point can be thought of intuitively as dividing the function’s rise by its run. As we shorten the distance we run, this ratio approaches the value of the function’s derivative at that point. See this in the demonstration from Maple Learn below.

It is impossible to fully grasp the idea of moving an infinitesimal distance, so we make it easier by asking: “If we move an extremely small distance to the right, how much do we move up?”.

Intuition is typically a beautiful tool for approximating limits, but limits tend to limit (pun intended) the utility of our intuition. A perfect example of this? The Staircase Paradox.

Consider any rectangle you’d like. In the following example, we'll use a rectangle of width 3 and length 4 for convenience, but this paradox extends to any rectangle.

The name of the game is to ask yourself: how far must we walk along the edge of the rectangle to get from the top left corner to the bottom right. Here, the distance is of course 7 units (3 units right and 4 units down). This looks like a bit of a scary fall, so let’s add some stairs.

Even with the stairs, we’re still travelling a total distance of 7 units (1.5 + 1.5 units right, 2 + 2 units down). To shorten the fall even more, we can keep adding more and more stairs.

The important thing to notice is that no matter how many stairs we add, the distance travelled is always 7.

Now you may be wondering, where exactly is the paradox? Well, imagine now we have an infinite number of stairs. Our intuition tells us that our path to the bottom becomes more like a slide instead of a staircase. The steps we take are infinitely small, so it seems like we’re just travelling in a straight line down to the bottom right corner. However, if this were the case, we would have a right triangle! Using the Pythagorean Theorem, the length of our travelled path would be sqrt(3²+4²) = 5.

In other words, our calculations from before were wrong! But... they can’t be wrong, because we saw that the total distance of 7 units travelled was independent of the number of stairs we added.

This is a consequence of something called the “Manhattan distance”, which is the distance you travel if you can only move horizontally and vertically, like navigating the grid of streets in Manhattan. No matter how small we make the steps in our staircase, we are still only moving right and down. We never actually move diagonally. So even though the staircase looks more and more like a straight line, its length is always computed using horizontal distance + vertical distance. The limit of the shapes is a diagonal line, but the limit of the lengths is not the length of that diagonal. And that’s where our intuition stumbles.

The key lesson of the Staircase Paradox is that a sequence of curves can converge to a straight line, while their lengths converge to something completely different.

This is one of the quiet but profound messages of higher mathematics: limits preserve some properties, but not all. Smoothness, shape, and position may converge nicely, while quantities like length, area, or curvature behave in more subtle ways. Mathematics has a gentle way of reminding us that how we measure something can matter just as much as what we’re measuring.

I think there may be a saboteur in the programming/Help department. For a beginner here are some cautions you WILL NOT FIND in Help system.

If you are writing a procedure and wisely choose to include a description:

format must be description " anything here " ;

MUST end with a colon or semicolon 
description MUST be lower case 
the comment MUST be enclosed in double quotes

If you want to view the description of procedure p
you MUST enter Describe (p) because describe(p) will not work nor will description (p);.

In future versions of Maple these rules may change-perhaps

format must be deScriPtiOn " anything here " ;#!!!
and if you want to view the description of procedure p you MUST enter DEsCriBbe ("p') ;

who knows what lies ahead?

Hi there, distinguished audience,

Let f(n)=n²+n+41.

further, require n to be a positive integer.
Look at the cases when f(n) is a prime number, or a composite number.
Beautiful parabola patterns appear.
see attached

writeup_for_prime_producing_trinomial_final.pdf

I also look at the case when there is

n²+n+17.

see

Lucky Number of Euler -- from Wolfram MathWorld

I can be reached by email at

matthewcharlesanderson2@gmail.com

also,

https://mattanderson.fun

Regards,

Matthew

Some mathematical theorems don't just prove a statement to be true, but they reveal something beautiful that itches our intuition. Viviani's Theorem is one of those rare gems. The theorem says something profound but geometrically elegant:

For any point inside an equilateral triangle, the sum of the perpendicular distances from that point to the triangle's three sides is always equal to the height of the triangle.

Take the equilateral triangle below as an example:

By picking any point P, we can draw lines perpendicular to each edge of the triangle that touch point P. The length of these lines always add to 6, which we will discover is the height of this triangle.

To explore this more, former Maplesoft co-op student Michael Barnett made a Maple Learn document on Viviani's Theorem where this is seen in action, as shown below.

No matter where the point P moves, the sum of perpendicular distances from that point to the edges of the triangle always add to the same value: the height of the triangle.

To see why this is the case mathematically, consider the example from before:

More generally, if we let x, y, and z be the shortest distances from the point P inside the triangle to the sides AB, AC and BC, respectively, one can conclude that:

In words, the sum of these distances x+y+z is simply the height of the triangle, h, no matter where the point P lies inside the triangle.

Even after reading this proof, it may be tempting to think of cases where this would not be true. I like to think of Maple Learn as a playground for geometry, algebra and visualization to interact. It helps to convince us that even for many different cases (in fact, all cases!), this theorem holds true.

Viviani's Theorem is a reminder that mathematics isn't always about answers. Instead, it's about finding hidden harmonies that our intuition begs us to question and search for. With tools like Maple Learn, those harmonies buried in symbols and complicated definitions can be uncovered and explored.

If geometry ever felt too distant or abstract, this is your invitation to see it come alive!

We've reached quite a rhythm with Maple Flow - we update frequently, we add lots of improvements and we move fast.

What does this mean for you? It means that the feedback loop between development, the user experience and course correction has a fast time constant.

Without you being loud and vociferous, the feedback loop breaks. So don't be shy - tell us what you want!.

The new 2025.2 update builds on the theme of connectivity with two popular tools - Excel and Python. On top of that, we also have many other features and fixes that you've asked for.

Earlier versions of Maple Flow let you 

• import and and export Excel data from Excel spreadsheets
• run Maple Flow worksheets in Excel with a mouse-driven UI to generate the communication glue

With the 2025.2 update, you can now copy and paste data from Excel into a Flow worksheet.

To be blunt, this is type of cross-application copy-paste behaviour is a no-brainer. It's such a natural workflow.

We've increasignly found that Python is now being used to script the interaction and data flow between different engineering tools. With Maple Flow 2025.2, you can now execute Maple Flow worksheets from a Python script. 

From Python, you can change and export any parameters and results defined in the worksheet

This gives me the dopamine hit of watching CPU utilization spike in the Task Manager (hey..I get my kicks where I can)

You can now do your parameter sweeps more quickly by executing the same worksheet in parallel, changing parameters for every run.

This is easy to set up - no special programming is needed.

• Print Extents can now be set globally for all sessions, or just for the current session.
• Any user-installed fonts used in the worksheet are now respected in the PDF export
• Worksheets execute faster
• The update includes fixes to many user-reported issues

You can install the Flow 2025.2 update via Help > Check for Updates (or if you're not already in the race, then grab a trial here and take Flow for a spin).

We're not pulling back on this aggresive development velocity, but we need you to point us in the right direction. Let's keep the feedback time constant small!

While conducting a workshop for business calculus students one day, I was reminded of a familiar challenge. Many students approach calculus with hesitation, especially those in business programs who may not see themselves as “math people.” Even when they are following the steps, it is not always clear that real understanding is happening.

During the workshop, we were discussing inflation as an example of exponential growth. I wrote the model on the board and explained how prices increase over time. Students were taking notes, but their expressions suggested they were still trying to connect the formula to its meaning.

So I opened Maple Learn.

I entered the equation, and the graph appeared right beside it. Almost immediately, the mood in the room shifted. One student leaned forward and said, “Oh… that’s what inflation looks like over time.”

That simple moment captured why visualization matters so much in calculus.

One of the strengths of Maple Learn is how naturally it combines symbolic work and graphical representation in a single space. Students can write equations, perform calculations, and see the corresponding graphs without switching tools. This makes abstract ideas feel more concrete and easier to interpret.

Maple Learn also works well as a note-taking tool. During the workshop, students kept their formulas, graphs, and written explanations together in one organized document. Instead of passively copying, they were actively building understanding as they worked through the example.

What stood out most was how easily students began sharing their work. They compared graphs, discussed small differences in their models, and asked one another questions. The technology supported conversation and collaboration, helping create a sense of community rather than isolated problem-solving.

By the end of the workshop, students seemed more confident and engaged. The combination of visualization, structured note-taking, and peer sharing helped transform a challenging topic into something accessible and meaningful.

Experiences like this remind me that when students can see mathematics, talk about it, and learn together, calculus becomes far less intimidating and far more powerful.

As a calculus instructor, one thing I’ve noticed year after year is that students don’t struggle with calculus because they’re incapable.

They struggle because calculus is often introduced as a list of procedures rather than as a way of thinking.

In many first-year courses, students quickly become focused on rules: differentiate this, integrate that, memorize formulas, repeat steps. And while procedural fluency is certainly part of learning mathematics, I’ve found that this approach can sometimes come at the cost of deeper understanding.

Students begin to feel that calculus is something to survive, rather than something to make sense of.

Research supports this concern when calculus becomes overly mechanical; students often miss the conceptual meaning behind the mathematics. That realization has pushed me to reflect more carefully on what I want students to take away from my class.

Over time, I’ve become increasingly interested in teaching approaches that emphasize mathematical thinking, not just computation.

Thinking Beyond Formulas

When I teach calculus, I want students to ask questions that go beyond getting the right answer:

1. What does this derivative actually represent?
2. How does the function behave when something changes?
3. Why do certain patterns keep appearing again and again?

These kinds of questions are often where real learning begins.

In The Role of Maple Learn in Teaching and Learning Calculus Through Mathematical Thinking, mathematical thinking is described through three key processes:

1. Specializing - exploring specific examples
2. Conjecturing - noticing patterns and testing ideas
3. Generalizing - extending those patterns into broader principles

This framework captures the kind of reasoning I hope students develop as they move through calculus.

What Helps Students See the Mathematics

One of the biggest challenges in teaching calculus is helping students see the mathematics, not just perform it.

It’s easy for students to get stuck in algebraic steps before they ever have the chance to build intuition. I’ve found that students learn more effectively when they can explore examples, visualize behavior, and experiment with ideas early on.

Sometimes that happens through discussion, sometimes through carefully chosen problems, and sometimes through interactive tools that allow students to test patterns quickly.

The goal isn’t to replace thinking it’s to support it.

A Meaningful Example

One activity highlighted in the study, Inflation and Time Travel, places exponential growth into a context students can relate to: wages and inflation.

When students adjust values, observe trends, and ask what happens over long periods of time, calculus becomes much more than an abstract requirement. It becomes a way of understanding real phenomena.

Activities like this remind students that mathematics is not just symbolic work on paper; it is a way of describing and interpreting the world.

Final Thoughts

For me, calculus is not meant to be a barrier course.

It’s meant to be a gateway into powerful ways of reasoning about change, structure, and patterns.

When students begin to specialize, make conjectures, and generalize ideas for themselves, they start to experience calculus as something meaningful, not just mechanical.

And as an instructor, that is exactly what I hope to cultivate in my classroom.

If one of our posts showed up in your social media feed recently, you may have found yourself staring at a giant maple leaf with feet and thinking, “Wait… who (or what) is that?” you’re not alone. 

Yes, that big, cheerful leaf you’ve been seeing is very real. 
And yes, they have a name. 

Meet Mathy. 

We officially introduced Mathy to the world a couple of weeks ago at JMM 2026 in Washington, DC, but their story actually started much earlier. 

Mathy was originally created by one of our developers, Marek Krzeminski, a few years ago as a fun internal character. Over time, they quietly became our in-office, local mathscot, popping up as mini 3D-printed Mathys around the office and even as a custom emoji someone created. 

Then, sometime last year, someone had what can only be described as a bold idea: 

What if we brought Mathy to life? 

And just like that, the giant maple leaf went from concept to costume. 

Mathy is fun, curious, and a little playful. That’s very intentional. That’s what math should feel like. 

We believe math matters. We also believe math should be approachable, joyful, and a place where curiosity is rewarded. Mathy reminds us, and hopefully others, that math doesn’t have to be intimidating. It can be fun, and it can inspire awe. 

I’ll be honest. When we decided to bring Mathy to JMM, I was a little nervous. Conferences are busy, serious places. Would people really want to interact with a seven-foot-tall maple leaf? 

As it turns out, yes. Very much yes. 

Researchers (from postdocs to seasoned academics), educators, and undergraduate and graduate students all stopped, smiled, laughed, and asked for photos. At one point, people were actually lining up to take pictures with Mathy.

Let’s just say: Mathy was a hit. 

How tall is Mathy? 
About 7 feet. They are hard to miss. 

What does Mathy love (besides math)? 
Dancing. Very much dancing. 
You can see for yourself here: Mathy's got moves!

Does Mathy talk? 
You bet they do. 

Now that Mathy has officially been introduced to the world, you’ll be seeing them more often on social media, at events, and in a few other fun places we’re cooking up. 

So if you spot a giant maple leaf dancing, waving, or talking math, now you know who they are. 

If you spot Mathy, don’t be shy, say hi.