The conference was held at Stanford from 30 July to 1 August 1986. The paper was accepted, presented, and then stranded: the proceedings never appeared. Forty years later, one of its authors has retyped the thing from Script/VM, a text formatting language of that era, into LaTeX and posted it to arXiv, where it landed on 29 July 2026. The note attached to the submission is matter-of-fact. It is posted, the authors write, for historical archival.
What Jean Della Dora and Stephen M. Watt had built was an implementation, in a computer algebra system called Scratchpad II, of something mathematicians call a linear ordinary differential operator. The idea is easier than the name. Take the operation "differentiate this function" and treat it not as a thing you do but as a thing you have: an object you can add to other objects, multiply by them, and, more interestingly, divide by them. Once differentiation is an object, an expression like "take the second derivative, add three times the first derivative, subtract twice the function" becomes a single mathematical item that behaves a lot like a polynomial.
A lot like, but not exactly. That gap is where the work lives.
Why order matters here
With ordinary numbers or ordinary polynomials, multiplication does not care about order: three times five equals five times three. Differential operators are not so accommodating. Differentiating and then multiplying by a function gives a different result from multiplying first and then differentiating, because the derivative of a product picks up an extra term. The algebra is what specialists call non-commutative, and the practical consequence is that a single familiar operation splits in two. There is no such thing as "dividing" one operator by another. There is dividing on the left and dividing on the right, and they are different problems.
Della Dora and Watt worked through the resulting catalogue. For operators whose coefficients live in a field, meaning a number system where you can always divide by anything nonzero, they give constructive algorithms, procedures that actually produce the answer rather than merely proving one exists, for left and right division, greatest common divisors, least common multiples, and an extended Euclidean algorithm. That last one is the ancient recipe for finding a common divisor of two quantities while also tracking how to rebuild it from the originals, which is exactly what you need for solving equations.
They also note a labour-saving symmetry: the right-hand constructions can be obtained from the left-hand ones by working in what is called the opposite ring, a mirror-image algebra in which multiplication is performed backwards. Prove it once, get the other version free.
When the coefficients are polynomials rather than a field, exact division stops working, so the authors turn to pseudo-division, a standard workaround that multiplies through by whatever is needed to make the division come out even. They also discuss an Ore localization, a construction that manufactures a workable system of fractions for a non-commutative setting where naive fractions would be ill-defined. The result is a right field of fractions.
The payoff the paper reaches for is factorization of differential equations. Factoring a polynomial breaks a hard problem into smaller ones; the same is true of a differential equation, and a factored operator can mean a solvable equation. To hunt for factors, the authors use the associated Riccati equation, a companion nonlinear equation whose solutions correspond to first-order factors, together with Newton polygons, a geometric bookkeeping device that reads off how badly a solution can blow up near a bad point. That analysis tells them what the singular parts of any factor could look like, narrowing the search.
The examples span operators with constant coefficients, elementary-function coefficients, rational-function coefficients, and matrix coefficients. What ties the paper to its moment is the software. Scratchpad II, the IBM research system that later became Axiom, had abstract data type facilities strong enough to make these operators first-class objects, things a user could hand around and combine freely, while still writing operator application in the ordinary notation. In 1986 that was not a given.
Why it matters
Computer algebra systems are now unremarkable infrastructure. Students and engineers ask software to integrate, differentiate, and solve symbolically without much thought about who worked out the rules the machine follows. Non-commutative operator arithmetic of the kind described here sits underneath the modern handling of linear differential equations, and the design question the authors were answering, how to represent an operator so that a program can manipulate it as an object while a human still reads it as familiar notation, is a question every symbolic system since has had to answer.
The honest framing is that this is a document, not a discovery. It reports work done in 1986 and reaches arXiv unchanged in substance, and the field has moved a long way in the intervening decades. Its value is as a record of how an early, capable system approached the problem, written by the people who did it, finally readable by anyone who wants to look.