Nothing writes an expression as a single quotient: no together / ratsimp

[Rafael-SOWNet]

There is no operation that writes an expression as a single quotient. Simplify never combines a sum over a common denominator, at any level:

"1 + 2/(1+t^2)"        Simplify ->  1 + 2 / (1 + t ^ 2)
"3 + 10*t/(t^2+1)"     Simplify ->  3 + 10 * t / (t ^ 2 + 1)
"1/(t^2+1) + 1/(t+1)"  Simplify ->  1 / (1 + t ^ 2) + 1 / (1 + t)
"a + b/c"              Simplify ->  a + b / c

Simplify(5) gives the same. Transformation.Rewriting(RewriteRules.CollapseMultipleFractions) does not do it either — that one moves nesting around without combining terms. Transformation.Rationalization is about clearing a surd from a denominator, which is a different job.

This is not a defect in Simplify. Putting a sum over a common denominator is a choice that makes some expressions worse, which is why other systems keep it as a separate operation — SymPy has together(), Maxima has ratsimp, Mathematica has Together. We do not have it at all, and that is the gap.

Where it bites

It is the blocker for the rest of the half-angle substitution family added in #1238. That rewrite turns a rational function of sine and cosine into a rational function of t = tan(x/2), and partial fractions answers the result — but only when the result is a single Divf of two polynomials. Where the rewrite leaves a sum with a fraction in it, nothing downstream can read it:

integrand	rewrites to	outcome
1/(1+cos(x))	1	answered, tan(x/2)
1/sin(x)	2/(1+t^2) / (2t/(1+t^2)), which collapses	answered, ln(tan(x/2))
1/(1-sin(x))	2/((t^2+1) * (1 + (-2)t/(t^2+1)))	declined
1/(1+cos(x)/2)	2/((t^2+1) * (1 + (2/(t^2+1) - 1)/2))	declined
1/(2cos(x)+3sin(x))	same shape	declined

Every declined row needs one step: distribute the outer factor into the bracket. (t^2+1) * (1 + (-2)t/(t^2+1)) is t^2 - 2t + 1, and then partial fractions answers it immediately.

I checked by hand that the algebra is otherwise right — building the quotient manually gives 2/(1 + t^2 - 2t) for the third row, which is 2/(t-1)^2 — so the substitution and the integrator are both fine and only the intermediate shape is in the way.

What it would take

A transformation that writes an expression as numerator / denominator with a single division at the root: recursively, a sum of quotients becomes one quotient over the product of the denominators, and a product of quotients multiplies through. It wants to be an explicit operation rather than part of Simplify, for the reason every other system keeps it separate.

Beyond unblocking the above, it is independently useful — it is a thing users ask a CAS to do — and it would feed partial fractions generally, since that already wants its input in exactly this shape and currently just declines anything that is not.

[Rafael-SOWNet]

Measured on master at 2eeb163: #1240 does this internally for the integrator (SingleQuotient), but nothing public does it yet.

                        RewriteRules.CommonDenominator                   Simplify
1/(t^2+1) + 1/(t+1)     (2 + t + t ^ 2) / ((1 + t) * (1 + t ^ 2))        as written
1 + 2/(1+t^2)           as written                                       as written
a + b/c                 a + b * 1 / c                                    as written

CommonDenominator puts a sum of quotients over one denominator, and a whole term beside a quotient stays as written.

Proposal: expose SingleQuotient as Entity.Together(), with MathS.Together and Transformation.Together, which is the name SymPy and Mathematica use. It returns one numerator over one denominator, cancels nothing, and is never applied by Simplify, as the issue says. OK to add?

[Happypig375]

"Together" sounds too vague, do mathematicians use this terminology, or is it a jargon artifact of engineers?

[Rafael-SOWNet]

Jargon, mostly: Together is Mathematica's name, and SymPy copied it. A mathematician says write it as a single fraction, or put it over a common denominator. So I'd name the result: AsSingleFraction(), with MathS.AsSingleFraction and Transformation.AsSingleFraction. OverCommonDenominator() would name the method instead, but it sits too close to RewriteRules.CommonDenominator, which does only part of the job. Which do you prefer?

[Happypig375]

AsSingleFraction seems better because of as feeling like seeing from a different perspective.

You should update the instructions to do critical thinking on naming and logic instead of copying blindly too.

[Rafael-SOWNet]

AsSingleFraction it is, and I'm building it now. The instructions are in #1617: a name is what a textbook calls the operation, and states the result; another system is only corroboration; and logic taken from one is checked against the mathematics before it is adopted.

[Rafael-SOWNet]

A correction to my first comment. "Nothing public does it yet" was wrong: I measured the rule sets and missed Transformation.RationalCanonicalization (#934), which already does this for rational functions. On master at 2eeb163:

1 + 2/(1+t^2)          (t ^ 2 + 3) / (t ^ 2 + 1)
1/(t^2+1) + 1/(t+1)    (t ^ 2 + t + 2) / (t ^ 3 + t ^ 2 + t + 1)
a + b/c                (a * c + b) / c
x/x                    1 provided not x = 0
sin(x) + 1/cos(x)      as written
sqrt(2) + 1/x          as written

It is a canonical form: reduced by the gcd, the denominator expanded and monic, and nothing outside rational functions over QQ. So AsSingleFraction has a narrower job than I said. It writes any expression as one fraction, functions included, so sin(x) + 1/cos(x) becomes (sin(x) cos(x) + 1) / cos(x). It cancels and expands nothing, so the denominator stays (1 + t)(1 + t^2). I'll build it with that scope and point its docs at RationalCanonicalization for the reduced form, unless you'd rather not have both.

[Happypig375]

It feels like the same operation at two different cost levels, maybe there is a better modeling approach here