Hi Maple community, and all,
an arbitrary arithmetic progression, with starting value , s, 

and increasing by "a", where "a" is the value to add, every time,
so
{Arithmetic Progression} is found by calculating
s+a*index

where index is a running index 
see attached
arithmetic_progression_with_1_and_8.mw

arithmetic_progression_with_1_and_8.mw

hopefully, that is useful, as an example, of an arithmetic progression.

Regards,
Matt

Hi Maple community and others,

I'm very proud to present my code.

Sequences are fun,
for those who know, about them

consider Fermat numbers, of the form,
F(n) = (2^(2^n)) + 1.
goes like

3, 5, 17, 257, 65537, 4294967297, 18446744073709551617, 
340282366920938463463374607431768211457, ...

in oeis.org database at
https://oeis.org/A000215 .

Similarly we can have base 3,

B(a) = (3^(3^a)) + 1.
goes like, this,
4,28,19684, ...
online, in database, with Universal Resource Location (URL)
https://oeis.org/A129290

There could also be base 4, that grows even faster
 

double_exponential_2_and_3_and_4.mw

That is all that I have, for now.

Thank you for this free forum.
regards,
Matt

Hi Maple community, and all,

Here is a little Maple worksheet, shoing an interesting property of prime numbers.

Numerical evidence supports Andreca's conjecture.

see    

_Andricas_conjecture.mw

good fun

see, also
Andrica's Conjecture -- from Wolfram MathWorld
Enjoy
regards,
Matt

PS online at https://MattAnderson.fun/

PPS Have a good day, everybody.

Last week, we launched the Maplesoft Math Success Platform. 
 

This launch reflects a lot of conversations I’ve had over the past year with educators and institutions about what it means to teach and learn math in the age of AI. 

At first, many of those conversations were about visibility. If students were completing homework, quizzes, and other assessments with help from AI, those results became harder to interpret. Did students understand the work, or had they copied down a solution that made sense in the moment without building the understanding needed to do something similar on their own?

That visibility still matters. 

Over time, though, those conversations led to a more nuanced conclusion. The question is not simply how we prevent students from taking shortcuts. It is how we help them develop the mathematical judgment, intuition, and critical thinking they will need in a world where AI is part of how they learn and work. 

In some ways, that has become even more important. When answers are easy to generate, students need to be able to test ideas, recognize when something does not make sense, explain their reasoning, and trust their own thinking. 

That is why I am proud to share the launch of the Maplesoft Math Success Platform. 

Built on Maple, the platform brings together our math technology and extends it with analytics, AI-driven insights, targeted resources, and content expertise to help institutions support math learning in a more complete way. 

It gives instructors and learning support teams better insight into where students are struggling, supports the creation of better questions and learning experiences, helps students move beyond the answer, and helps institutions respond to a world where AI is now part of how students practice, study, and get help. 

You can learn more about the Maplesoft Math Success Platform on our website.

We also wrote more about the thinking behind this launch in our new whitepaper, Math Education in the Age of AI: From Grading Answers to Understanding Student Progress. It looks at why math education needs a new approach in the age of AI: one that helps instructors ask better questions, create learning experiences that build understanding, and use learning signals to see where students need support.

I’d love to hear what you think. How are you seeing AI change the way students learn, practice, and get help in math? And what kinds of tools or approaches do you think will be most important as math education continues to evolve?

A note on what I've been working on for the past while. Some of you may have seen the announcement on LinkedIn yesterday; this is for the home audience.

The question I've been chasing is the one that's underneath the Physics package, the dsolve / pdsolve formal methods and heuristics, the advanced Mathematical Functions and FunctionAdvisor, and most of what I've written for Maple over the years. How can mathematicians and physicists speed up significantly their work using Computer Algebra Systems (CAS) and at the same time trust the result a computer hands back? The new chapter is what happens when AI sits between the human and the CAS, and the answer to that, in my view, turns out to be a much harder problem than the AI hype suggests.

Why? Because AI is increasingly the driver of computational mathematics in research, engineering, and education. And the unsolved problem isn't whether AI can do mathematics. It can. The problem is that an incorrect AI result arrives with the same confidence as a correct one.

On 100 challenging problems of undergraduate mathematics we tested, six independent state-of-the-art AIs returned mathematically equivalent answers on only 21% of them, and even within a single AI, repeated runs disagreed with themselves on 3% to 57% of the problems (details). The gap this validation crosses, between probabilistic inference and certified mathematical computation, is epistemological, not technological. It won't close with more training data. It needs validation across multiple AIs and multiple CAS, with no single engine having the final word.

ExaktAI aims to address that gap. It guides AI through mathematical computation, validates each step against Maple and Mathematica, and automatically generates and opens a corresponding CAS document where the validation can be audited and reproduced for every step, and where one can continue working on the problem. The goal: AI-mathematics that is validated, with the human in the loop.

ExaktAI is now well developed (TRL 6: System prototype demonstration in a simulated environment, on the ISED / Innovative Solutions Canada TRL scale). At the end an image. A Beta is scheduled for late summer / fall 2026; details at exaktai.ai.

In summary: ExaktAI is my present, and if you work on AI for mathematics and computer algebra, or the validation problem for AI, I'd love to hear your perspective.



Edgardo S. Cheb-Terrab
ExaktAI
Research Fellow Emeritus at Maplesoft.

Hi MaplePrimes, and all,

Here is a new, to me, set of numbers
defined by ,
the first three numbers are {1,2,3}
and then, 
the next number is the sum of the three 
previous numbers,
so,
{1,2,3,6,11,20, ... }
but can only calculate a finite number of numbers
the, so called, Tribonacci numbers
could start with {0,1,0}
see online
https://oeis.org/A001590

and
triple_recursive_sequence_simple_first.mw

triple_recursive_sequence_simple_first.pdf

regards,
Matt
 

Hi again Maple community, and others,

want to share
tiwn_and_cousin_prime_numbers.mw
tiwn_and_cousin_prime_numbers.pdf
(spelling error in file name)

~

just want to share,
some successful code

The lesser of the twin primes are listed
{3,5,11,17,29,41,59,71}
https://oeis.org/A001359
Prime numbers p such that p+2 is also a prime number

also, the lesser of the cousin primes are listed
{3,7,13,19,37,43,67,79,97}
https://oeis.org/A023200
prime numbers p such that p+4 is also a prime number

good fun

also, my webpage has more details
https://mattanderson.fun
okay

regards,
Matt

Hi Maple community, and all,

My intrest in prime numbers continues.

Made a quick example file.

3_tuple_admissible_example.mw

3_tuple_admissible_example.pdf

also, see my webpage for similar content
https://mattanderson.fun
and Norman, in Germany
prime k-tuplets & Primzahlen

Enjoy

Matt

Mathematics often feels precise and deterministic. We solve equations, follow logical steps, and do our best to arrive at exact answers. But sometimes, surprisingly, randomness can also lead us to deep mathematical truths. One of the most famous examples of this idea is a problem from the 18th century known as Buffon’s Needle.

Imagine you have a floor made of long wooden planks placed side by side. The seams between the planks form a set of equally spaced parallel lines across the floor. Now, suppose you take a needle and randomly drop it onto the floor. Sometimes the needle lands entirely on one plank. Other times, it crosses one of the seams between planks, as shown below.

Now here is the curious question posed by the French mathematician Georges-Louis Leclerc, Comte de Buffon in the 1700s:

If we repeatedly drop the needle at random, what is the probability that it crosses one of the lines on the floor?

At first glance, this sounds like a simple probability puzzle. But the answer turns out to involve one of the most famous numbers in mathematics: π.

To keep things simple, assume the distance between the parallel lines on the floor is the same as the length of the needle. We can also imagine that all of our needles are thrown onto the same plank, potentially crossing onto the plank above or below. This configuration is equivalent to throwing the needle onto any plank as long as the planks are equally wide; this modification makes the analysis much simpler.

Every time the needle lands, two things determine whether it crosses a line:

• The distance x from the center of the needle to the nearest line
• The angle θ at which the needle lands with respect to the parallel lines

See a depiction of this below.

To determine the probability of a needle crossing one of these lines, we need to describe what a "random drop" of the needle means mathematically. If the lines are the same length apart as the length of the needle L, then the center of the needle can never be farther than L/2 from the nearest line. Therefore, 0 ≤ x ≤ L/2. Next, we can simplify our domain for θ. The problem is symmetric, so we only need to consider angles between 0 and π/2. Any given half of the needle then has a vertical reach of (L/2)sin(θ).

We will say a needle "crosses" a line precisely when the center lands close enough to a line that one end of the needle can reach across the line. This occurs when x ≤ (L/2)sin(θ).

An important assumption to make is that every pair (x,θ) in the rectangle 0 ≤ x ≤L/2, 0 ≤ θ ≤ π/2 is equally likely. We’re assuming the needle lands with uniform randomness over all vertical positions x and angles θ. This means that the probability of crossing a line is the fraction of this region where the inequalities above hold. That is, 

Probability = (area of favourable region) / (area of total region)

The "rectangle" formed by inequalities has a total area of (L/2) * (π/2) = π*L/4. The needle crosses a line exactly when x ≤ (L/2)sin(θ), so for a fixed angle θ, the allowable x values are 0 ≤ x ≤ (L/2)sin(θ). The favourable area is then:

The probability of a needle crossing a line is therefore:

This result leads to a fascinating idea. If the probability of crossing a line is 2/π, we can rearrange the formula to estimate π itself:

π ≈ 2N / C

where:

• N = the total number of needle drops
• C = the number of times the needle crosses a line

In other words, by performing a simple random experiment and counting how often the needle crosses a line, we can approximate π.

For example, suppose you drop the needle 10,000 times and it crosses a line 6,366 times. Plugging these values into the formula gives

π ≈ (2 × 10,000) / 6,366 ≈ 3.14

With enough trials, the estimate tends to get closer and closer to the true value of π. At the bottom of this post, I attached a Maple worksheet that simulates this phenomenon. Below are results from simulating this result using N = 10, 100 & 1000, respectively. Notice as N increases, our approximation for π tends to become more and more accurate.

Below is a more dynamic simulation from the Maple worksheet to show how the approximation stabilizes as N increases.

What makes Buffon’s Needle so fascinating is the unexpected connection between geometry, probability, and one of mathematics’ most important constants.

π usually appears when dealing with circles (circumference, area, rotation, etc). But in Buffon’s experiment, there are no circles at all. Instead, π emerges from the geometry of all the possible ways a needle can land on a set of parallel lines.

This was one of the earliest examples of what we now call a Monte Carlo method, which is essentially using random experiments to estimate numerical values. Today, similar techniques are used in physics, finance, computer graphics, and machine learning.

One of the best parts of Buffon’s Needle is that you can try it yourself. All you need is:

• A toothpick or needle
• A piece of paper with a sequence of parallel lines, each a distance of the needle's length apart
• A lot of patience

Drop the needle repeatedly (N times), record how many times it crosses a line (C), and compute 2N/C. The more times you repeat the experiment, the closer your estimate will get to π.

After reading about this experiment, I was convinced that mathematics is not only about abstract symbols and formulas. Sometimes, even something as simple as dropping a needle onto the floor can reveal the hidden structure of elements of the universe that we would've otherwise never known were there.

Buffons_Needle_Simulation.mw

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.

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.

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.

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.

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!