Simplifying a very long symbolic expression by automatically introducing temporal variables or in any other way

Question

After attempting to solve a symbolic math problem, I got an expression with about 17000 characters. I am using the symbolic toolbox for Matlab, but I am open to any suggestion (Mathematica, whatever).

For obvious reasons, I won't copy-paste the expression straight into the question. Here is a link instead.

Running the Matlab commands simplify and simple, and even attempts to collect didn't improve the situation (Some got it worse).

But I am wondering, I don't care if the expression is evaluated in steps, with temporal parameters. Something like:

 z1 = a^2*y1;
 %Now the expression can be simplified by using z1 as alias!
 z1+z1^2 ....

Is there an automatic method to get such a step-by-step simplification with temporal variables? Also, any other method that you can think of is plausible.

Answer 1

Might try common subexpression elimination (CSE). Here is an example cribbed from

Get mathematica to simplify expression with another equation

InputForm[Experimental`OptimizeExpression[(3 + 3*a^2 + Sqrt[5 + 6*a + 5*a^2] +
      a*(4 + Sqrt[5 + 6*a + 5*a^2]))/6]]

==>

Out[206]//InputForm=
Experimental`OptimizedExpression[Block[{Compile`$1, Compile`$3, Compile`$4, 
   Compile`$5, Compile`$6}, Compile`$1 = a^2; Compile`$3 = 6*a; 
   Compile`$4 = 5*Compile`$1; Compile`$5 = 5 + Compile`$3 + Compile`$4; 
   Compile`$6 = Sqrt[Compile`$5]; (3 + 3*Compile`$1 + Compile`$6 + 
     a*(4 + Compile`$6))/6]]

Answer 2

As I wrote in my comment, it seems that Mathematica’s simplification tools are more efficient than similar commands in Matlab. Since it seems that you are a Matlab user, I give you here a detailed instruction how to use just two of the simplification commands of Mathematica. If you define your long expression as

longExpression = (x3^2*(y2+y3-a*y1-a*y2-2*a*y3-...

Then you can use

Simplify[longExpression]  
and 
FullSimplify[longExpression]

The last produces a nice and clear expression which has just 1535 characters (sounds much, but there are not so many variables). Perhaps this is enough simplification for your problem. If not, then let us know.