9

To my understanding, the function Simplify[] and FullSimplify[] work by applying a series of built-in transformation rules to the expression and trying to minimize the TransformationFunctions in the process, which by default is LeafCount[].

In my recent work I need to simplify a lot of symbolic expressions involving elementary functions as well as a special function Erfc[]. While Simplify works fine for simple expressions, it is extremely time-consuming for more complicated expressions. Some complicated expressions take days to be simplified. And FullSimplify[] takes hours even for very simple expressions. I do not have much experience in symbolic computation, and I desperately need some help.

Specifically, is there any general suggestions to accelerate Simplify[] or FullSimplify[]? For example, in order to accelerate it, is it possible to:

  1. Change the default ComplexityFunction?
  2. Change the default TransformationFunctions?
  3. Utilize parallel computation?
  4. Utilize Compile?

If they are possible, how should I do those things? Also, what is a suitable value for TimeConstraint?

m_goldberg
  • 107,779
  • 16
  • 103
  • 257
Y.X
  • 321
  • 1
  • 6
  • 1
    1: Yes, see documentation of ComplexityFunction; 2: Yes, see documentation of TransformationFunctions; 3: No (unless you can split up your expressions). 4 No. – Sjoerd C. de Vries Oct 08 '15 at 11:04
  • @SjoerdC.deVries Thanks for the comment. Of course I am ALLOWED to change these; that I am well aware of. My questions is whether it is possible to change them to accelerate the computation, and how to do that : ) – Y.X Oct 08 '15 at 12:36
  • You state that LeafCount is the current ComplexityFunction. That is not entirely true. You can find information about the actual function at the bottom of the ComplexityFunction page. It uses some extra stuff to take complexity of the numbers used in your expression into account. You might try changing the default function to LeafCount to see whether that helps. – Sjoerd C. de Vries Oct 08 '15 at 12:44
  • Using TransformationFunctions to reduce the number of transformations will quite logically reduce time, but will, at the same time, probably have a negative impact on the results. – Sjoerd C. de Vries Oct 08 '15 at 12:46
  • Yes, you are right about the default ComplexityFunction. I have tried to modify the ComplexityFunctions in various ways, but that did not make much differences. It seems that trying different transformation rules takes up most time. – Y.X Oct 08 '15 at 13:10
  • @SjoerdC.deVries Is there any documents/guidelines about customizing TransformationFunction, i.e., how to define suitable transformations functions s.t. FullSimplify generates satisfying results? The document gives nothing about how that should be done. Again, thanks for the comment : ) – Y.X Oct 08 '15 at 13:14
  • Use Assumptions option to include any constraints on parameters or variables. Assign any known values. – Bob Hanlon Oct 08 '15 at 16:24
  • 4
    I've found that the best way to speed up simplifications is to first think for yourself which parts are never going to simplify together, like two independent parameters a, b for example, or perhaps in your example the Erfc[] is not going to simplify with the elementary functions. Then you use instead of Simplify[expression], Collect[expression,{a,b,Erfc[_]},Simplify]. This way you prevent mathematica from working on parts of the problem you know won't simplify. – Jansen Oct 08 '15 at 19:29
  • Here is a discussion that may be of interest to you: Advice for Mathematica as Mathematician's Aid – MarcoB Oct 08 '15 at 23:31
  • You could also possibly replace sub expressions by variables to simplify the expression. To find sub expressions in an expression you can use this answer. If you want something more customized to your need you can use Experimental`OptimizeExpression[expression]. The output is a bit difficult to read but if I remember correctly you can use this answer to simplify the view (does not provide a direct method with ``ExperimentalOptimizeExpression but if I remember you can use it as inspiration). – userrandrand Aug 19 '22 at 01:33
  • Without some specific information about your "real problem" it is not possible to give good advice. For example, why do you need to "simplify" your expressions? For most complicated expressions there is diminishing returns in trying harder to simplify it. – Somos Dec 06 '22 at 20:37
  • The default ComplexityFunction is not LeafCount but Simplify`SimplifyCount – rnotlnglgq Dec 08 '22 at 02:33

1 Answers1

3

Without a test expression, I can give some ideas that have worked. I'm not sure there's an idea that always works.

Often the problem is probably the combinatorial explosion of things to try as an expression grows large.

Simplify will do less and do it faster; sometimes it helps. Likewise, putting a TimeConstraint on the first call makes it do less faster. If the quick one does lots of little simplifications it can make the big simplification faster.

FullSimplify[Simplify[expr]]
Simplify[Simplify[expr, TimeConstraint -> 0.1]]

For a similar reason, simplifying part of the expression first can help.

Simplify[Map[Simplify, expr, {5}]]
Simplify[Map[Simplify, expr, {-5}]]

You can put FullSimplify for Simplify as might be needed. FullSimplify will tackle special functions; Simplify will not.

If you know something about the structure of expr, some approaches will seem more likely than others to be successful.

Michael E2
  • 235,386
  • 17
  • 334
  • 747