Surprises simplifying simple polynomials

Question

I came across some somewhat surprising behavior of Simplify today, on something very simple. Let's take two cubic polynomials that we know have the same value:

bySum = Sum[k^2, {k, 1, n}]

(1/6)*n*(1 + 3*n + 2*n^2)

byBernoulli = (BernoulliB[3, n + 1] - BernoulliB[3])/3

(1/3)*((1 + n)/2 - (3/2)*(1 + n)^2 + (1 + n)^3)

Now, I haven't done anything to simplify these two polynomials, so it's no surprise that they look different. However, Simplify helps less than you might think:

{bySum, byBernoulli} // Simplify

{(1/6)*n*(1 + n)*(1 + 2*n), (1/6)*n*(1 + 3*n + 2*n^2)}

Mathematica can still figure out that they're the same if you ask it, but the Simplify'd forms are different.

bySum == byBernoulli // Simplify

True

I was somewhat surprised by this. FullSimplify works as I'd expect, but this isn't the sort of problem where I'd expect to need it.

For what it's worth, this is Mathematica 8.0.4 on Windows 7 (x64).

Answer 1

FullSimplify is Simplify with additional transformation rules; some of these rules may be necessary to simplify a polynomial to a form where you can see the equality explicitly.

In case of polynomials, I usually use Simplify@Expand to group terms the same way; Expand brings the polynomial in an unambiguous standard form, at which point both results should be the same already. Applying Simplify afterwards is merely a matter of making it more readable.

polySimplify = Simplify[Expand[#]] &;

bySum = Sum[k^2, {k, 1, n}];
bySum // polySimplify

byBernoulli = (BernoulliB[3, n+1]-BernoulliB[3])/3;
byBernoulli // polySimplify

1/6 n (1+3 n+2 n^2)
1/6 n (1+3 n+2 n^2)

Answer 2

We get different results because Simplify, working with a smaller range of accessible transformations than FullSimplify does, applied to structurally very different expressions at the begining, reaches only the local minimum of the default ComplexityFunction, being roughly close to LeafCount, unlike in case of FullSimplify even though its underlying ComplexityFunction may be the same.

Having defined :

bySum = Sum[k^2, {k, 1, n}];
byBernoulli = (BernoulliB[3, n + 1] - BernoulliB[3])/3;

we get :

bySum == byBernoulli // Simplify

True

because

Simplify[byBernoulli - bySum]

0

even though Simplify yields different results here :

  {bySum, byBernoulli} // Simplify

This is because at the begining we have very different forms of the expressions which we can observe with help of TreeForm and LeafCount assessing the complexity :

LeafCount /@ { bySum, byBernoulli, byBernoulli - bySum }

{13, 26, 40}

TreeForm /@ {bySum, byBernoulli}

A kind of expression not involving special functions where FullSimplify simplifies it in a much better way than Simplify one can find here. Knowing that algorithms behind FullSimplify contain a much wider range of transformations than Simplify the latter finds at certain stage only a local minimum (not sufficient in case of byBernoulli // Simplify to reach the global minimum) of the actual complexity function and therefore the resulting expressions are slightly different :

LeafCount /@ {bySum // Simplify, byBernoulli // Simplify}

{13, 15}

TreeForm /@ {bySum // Simplify, byBernoulli // Simplify}

unlike in case of FullSimplify :

{bySum , byBernoulli } // FullSimplify

We needn't use FullSimplify to get the same expressions, a simpler solution of the problem would be this :

{bySum, byBernoulli} // Factor

which is the same as the result of FullSimplify for the both expressions as well as Simplify for bySum. It should be mentioned here, that FullSimplify when applied to a factorizable polynomials tends to give that polynomial in the factorized form, i.e. Factor[poly] yields by default its factorized form if poly is factorizable in the field of rationals, however if we extend the rationals appropriately the results will be different, e.g. Factor[1 - 10 x^2 + x^4, Extension -> {Sqrt[2], Sqrt[3]}] (see this answer). So this is rather a special case, a more genreal approach (also for polynomials not factorizable in the rationals)
would be :

{bySum, byBernoulli} // Collect[#, n] & // Simplify

The result is the same as in the case of byBernoulli // Simplify.