Cfrtjryk

Why does FullSimplify[Cosh[a] + Sinh[a] + Sin[a]] not return Exp[a]+Sin[a]
?

Is this some bug in Mathematica or am I being stupid? Is the latter not simpler by some measure?

I've ran into this several times so I guess others have too, therefore i find it hard to believe it is a bug (it should have been reported many times and surely have shown up during their testing).

One problem seems to be that the only pair of terms in a Plus[t1, t2,...,] expression that are simplified are the last two. This shows up not only in the starting expression Cosh[a] + Sin[a] + Sinh[a] (in that order due to the Orderless attribute of Plus) but also in TrigToExp:

TrigToExp[Cosh[a] + Sinh[a] + Sin[a]]

(*  1/2 I E^(-I a) - 1/2 I E^(I a) + E^a  *)

When this is simplified we get the original expression back.

Probably it was thought that pointlessly simplifying $n(n-1)/2$ pairs of terms in a long expression would probably slow down simplification too much. Since one pair but not all pairs are checked, I feel this was a deliberate choice. I'd be reluctant to call it a bug, but it certainly is a shortcoming in this case.

A workaround is to create a transformation function that checks all pairs:

ClearAll[allpairs];

allpairs[e_Plus] := 

  First@SortBy[e - # + FullSimplify[#] & /@ Subsets[e, {2}], Simplify`SimplifyCount];

allpairs[e_] := e;



FullSimplify[Cosh[a] + Sinh[a] + Sin[a], TransformationFunctions -> {Automatic, allpairs}]

(*  E^a + Sin[a]  *)

Another workaround, showing that some standard identities are missing from the automatic transformations:

FullSimplify[Cosh[a] + Sinh[a] + Sin[a], 

 TransformationFunctions -> {Automatic,

     # /. Cosh[z_] -> Exp[z] - Sinh[z] &,

     # /. Sinh[z_] -> Exp[z] - Cosh[z] &}]



(*  E^a + Sin[a]  *)

EDIT: As commented on by Kuba

expr = Cosh[a] + Sinh[a] + Sin[a];

Initially assume that a is real (default for ComplexExpand)

expr2 = expr // TrigToExp // ComplexExpand



(* E^a + Sin[a] *)

Then check if the expressions are equal for all (complex) values of a

expr == expr2 // Simplify



(* True *)

EDIT 2: Alternatively, since Michael E2 states that Mathematica "simplifies the last two terms in a sum", vary the ordering of the terms

SortBy[Total /@ FullSimplify@Table[TakeDrop[expr, {n}], {n, 3}], 

  LeafCount][[1]]



(* E^a + Sin[a] *)

EDIT: There is a simple specific to the case solution as well:

FullSimplify[Cosh[a]+Sinh[a]+Sin[a],ExcludedForms->_Sin]

(* E^a+Sin[a] *)

The reason why it works is explained below.

Firstly, the simple solution: You need to use ComplexExpand as a transformation function:

FullSimplify[Cosh[a]+Sinh[a]+Sin[a],TransformationFunctions->{Automatic,ComplexExpand}]

(* E^a+Sin[a] *)

Explanation

I do not know why this happens but my guess is as follows. The observation of OP is probably because of the way transformation functions work. If I have a transformation function g, then FullSimplify applies it to all subexpressions f[x1,x2,...,xn] and checks g[f[x1...xn]] is simpler than f[x1...xn] (well, not one by one for each subexpression but the whole expression). In particular, this means that FullSimplify compares

Cosh[a] + Sin[a] + Sinh[a] 

and

1/2 I E^(-I a) - 1/2 I E^(I a) + E^a

where second output follows from the transformation function TrigToExp. Here, the key point is this: Since Plus has the Flat attribute, TrigToExp also applies to Sin[a], and one cannot avoid that. Say, if Plus did not have this attribute, we could have had a scenario where the transformation is applied only the other two without affecting Sin[a], which is possible only if they are not at the same subexpression.

This explanation is in contrast to @Michael's explanation as far as I understand. In particular, one can see that this simplification is no issue if the middle term was not expanded by TrigToExp:

FullSimplify[Cosh[a]+Sinc[a]+Sinh[a]]

(* E^a+Sinc[a] *)

in contrast to, say,

FullSimplify[Cosh[a]+Cos[a]+Sinh[a]]

(* Cos[a]+Cosh[a]+Sinh[a] *)

One can check that indeed TrigToExp expands Cos but not Sinc. So the issue is not the order of terms nor that Fullsimplify does not consider different pairs.

Once we add ComplexExpand into the transformation functions, we now have FullSimplify comparing original expression with ComplexExpand[TrigToExp[#]]& transformation, and these are:

{#,ComplexExpand[TrigToExp[#]]}&[Cosh[a]+Cos[a]+Sinh[a]]

(* {Cos[a]+Cosh[a]+Sinh[a],E^a+Cos[a]} *)

Now since one expression is shorter than the other, FullSimplify can immediately choose the correct one!

Summary

I would say that there is no bug with FullSimplify, at most a shortcoming. The solution I proposed above is actually inherently using another information we presented, that $a$ is real (even though the result is actually true for a bigger domain). That FullSimplify can do better simplifications under restricted domains even though the simplifications are actually correct for the original domain is disturbing, but it is not a bug, only a shortcoming.