In my third year as a computer science undergraduate at a university in Hong Kong, I began studying the mathematics department’s ordinary differential equations courses on my own. I was already comfortable programming in C and Java, and I had long enjoyed mathematics and physics. ODEs gave me a question that brought those interests together. Working through examples in Kamke’s handbook, I kept encountering substitutions and rearrangements that were easy to verify once someone showed them to me, but hard to discover in the first place. Could a systematic theory explain when those tricks work and how to find them?

Discovering Maple changed how I thought about that question. Through its documentation and the work of E. S. Cheb-Terrab and others, I learned how Lie symmetries, differential invariants, and first integrals can make parts of ODE solving systematic. I also began studying Liouvillian integrability, invariant algebraic curves, and differential Galois theory. I found myself asking what structure an equation reveals, even when its solutions resist a familiar closed form.

Abel equations became a natural place to look. Their solution structure is rich, and differential invariants under changes of the independent variable and affine changes of the dependent variable give a way to compare equations that look quite different. The classification of integrable Abel equations by Cheb-Terrab and A. D. Roche made that idea concrete: equations scattered across different sources could be recognized as members of the same class. I began to wonder how far we could take this if the substitution itself were allowed to be nonlinear.

I started working systematically on this inverse problem around the first year of graduate school. Given a rational first-order equation y' = M(x,y)/N(x,y), can we recover a nonconstant rational substitution u = A(x,y)/B(x,y) that leaves x unchanged and makes u' a polynomial in u? If the reduced equation belongs to a known integrable class, the substitution gives us a route to solving the original equation. Even when it does not, a successful reduction exposes structure that is hard to see in the original coefficients.

My first paper in Maple Transactions treated the nondegenerate case, where the relevant factors survive when the rational equation is put in lowest terms. The software from that work was subsequently licensed to Maplesoft. My second paper studied what happens when factors cancel. It develops a practical bounded search as well as a full algorithm that does not require the user to supply a degree bound for the transformation.

The insight I found most rewarding was that cancellation can point to an invariant algebraic curve of the original system. In the cancellation setting treated in the paper, a factor that disappears from the reduced fraction can encode an algebraic solution curve. Recovering it can therefore give us two things at once: a substitution that simplifies the ODE and geometric information about the original vector field. Invariant algebraic curves can be difficult to find directly. Obtaining one as part of a reduction is a good example of what I value in Maple’s approach to ODEs: a symbolic computation can tell us something about the equation even before we ask for its general solution.

The cancellation case is also the more expensive one. When the initial constraints leave several possibilities, the algorithm may have to fall back on nonlinear algebra. In discussions with GPT, one suggestion gave me a particularly useful way to approach that bottleneck: expand the reduction identity locally at a pole, then use the first few terms—the jet—to derive linear constraints on the unknown numerator.

Those constraints can be tested at a regular rational value of x, using exact arithmetic. A branch whose necessary conditions are inconsistent can be discarded before costly symbolic elimination. For a surviving branch, the symbolic calculation still takes place over the rational function field. If the linear constraints determine a unique normalized numerator, the implementation can recover the target coefficients and verify the substitution directly. Otherwise, it retains the nonlinear fallback. The main gain is that expensive computations are reserved for branches that survive cheaper tests; the speedup depends on how much those tests narrow the search.

Maple source (.mpl):GeneralizedAbel_Maple.txt

For inputs over the rational numbers, ReduceHigher is sound and complete for target equations of actual degree n > 2, with the independent variable unchanged and no user-supplied bound on the transformation degrees. Every reported reduction satisfies the exact differential identity, and a completed search can rule out reductions in this class. That guarantee does not extend to the general Riccati case n = 2.

Load the source with read and pass the numerator and denominator of the original slope:

restart:
read "GeneralizedAbel.mpl":

M := (y+x)^5 + (x*(y+x)-2)*(y-1)^2:
N := (y-1)*(y-x-2):

t0 := time():
R := GeneralizedAbel:-ReduceHigher(M, N, x, y, u):
elapsed := time()-t0:

R["status"];
R["transformation"];
R["equation"];
R["residual"];
elapsed;

In one Maple 2026 run, the search returned FOUND in 0.171 seconds of CPU time, excluding source loading. The transformation and reduced equation were:

u = (x^2 + y^2 + 2*x)/(y - 1)
u' = (u + 2*x)^3 + x*(u + 2*x) - 2

The exact residual was 0. The returned substitution is a normalized form of v = (y+x)^2/(y-1), with v = u + 2*x. In this form, the cancelled factor y+x also has a geometric interpretation: the line y = -x is an invariant algebraic solution curve of the original equation.

I plan to attend ISSAC 2027 in Tsukuba, Japan, July 12–15. If you work on ODEs, symbolic computation, or invariant curves, I would love to meet you there and hear what examples or questions you would bring to this problem. I would also like to share some of the projects related to Maple that I am currently working on.

I hope the Maple community will see rational reduction as a symbolic computation problem in its own right. Finding a change of variables, deciding whether one exists in a specified class, and understanding what it reveals about a vector field are worthwhile goals—even when the next step is not a call to dsolve.

— Shaoxuan Huang

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.