A better simplification function

Question

I am creating this question and posting an answer to it as a help for those who have problems with Mathematica simplification oddities that appear in other questions on the site.

First of all, there were simplification problems like this one:

Simplify[x + y, x + y == a]
(* ==> x + y *)

Simplify[x + y, x + y == z]
(* ==> z *)

We can see that the culprit is the well known variables names problem in Mathematica simplification. One of the answers points out a simplification function developed by Adam Strzebonski that is based on a series of FullSimplify calls with permutations of the symbols names, in hope of achieving the desired result:

VOISimplify[vars_, expr_, assum_: True] := Module[{perm, ee, best},
    perm = Permutations[vars];
    ee = (FullSimplify @@ ({expr, assum} /. Thread[vars -> #])) & /@ perm;
    best = Sort[Transpose[{LeafCount /@ ee, ee, perm}]][[1]];
    best[[2]] /. Thread[best[[3]] -> vars]
]

It works:

VOISimplify[{a, x, y}, x + y, x + y == a]
(* ==> a *)

Now, testing FullSimplify and VOISimplify on another simplification problem in this question, we don't have success (the z variable is not canceled):

FullSimplify[(E^(-I x) y z + (1 + E^(I y)) (x + y) z)/z, z != 0]
(* ==> (E^(-I x) y z + (1 + E^(I y)) (x + y) z)/z *)

VOISimplify[{x, y, z}, (E^(-I x) y z + (1 + E^(I y)) (x + y) z)/z, z != 0]
(* ==> (E^(-I x) y z + (1 + E^(I y)) (x + y) z)/z *)

One of the answers to this question was to simply change the variable name from y to a:

FullSimplify[(E^(-I x) y z + (1 + E^(I y)) (x + y) z)/z /. y -> a,  z != 0]
(* ==> a E^(-I x) + (1 + E^(I a)) (a + x) *)

We can see that even VOISimplify has a problem. How to deal with this case?

Answer 1

It is proposed an improvement based on VOISimplify:

ExpressionUnknownSymbols[expression_]:=Union@Cases[expression,Except[__Symbol?(Context@#==="System`"&),_Symbol],{1,Infinity},Heads->True]
SetAttributes[ExpressionUnknownSymbols,Listable];

Options[SuperFullSimplify]={Assumptions->False,ComplexityFunction->Automatic,ExcludedForms->{},TimeConstraint->Infinity,TransformationFunctions->Automatic,Trig->True};
SuperFullSimplify[expression_,options:OptionsPattern[]]:=SuperFullSimplify[expression,True,options]
SuperFullSimplify[expression_,assumptions_,OptionsPattern[]]:=Module[{unknownSymbols,unknownSymbolsPermutations,a,simplificationVersions,bestSimplification},Quiet[
    unknownSymbols=Union[ExpressionUnknownSymbols[expression],ExpressionUnknownSymbols[assumptions]];
    unknownSymbolsPermutations=Permutations[Table[Unique[a],{i,Length[unknownSymbols]}]];
    With[{parallelKernelAssumptions=$Assumptions},ParallelEvaluate[$Assumptions=parallelKernelAssumptions]];
    simplificationVersions=ParallelMap[FullSimplify[expression/.Thread[unknownSymbols->#],Assumptions->(If[OptionValue[Assumptions]=!=False,OptionValue[Assumptions],$Assumptions&&assumptions]/.Thread[unknownSymbols->#]),ComplexityFunction->OptionValue[ComplexityFunction],ExcludedForms->OptionValue[ExcludedForms],TimeConstraint->OptionValue[TimeConstraint],TransformationFunctions->OptionValue[TransformationFunctions],Trig->OptionValue[Trig]]&,unknownSymbolsPermutations];
    bestSimplification=Sort[Transpose[{ParallelMap[If[OptionValue[ComplexityFunction]===Automatic,Simplify`SimplifyCount,OptionValue[ComplexityFunction]],simplificationVersions],simplificationVersions,unknownSymbolsPermutations}]][[1]];
    bestSimplification[[2]]/.Thread[bestSimplification[[3]]->unknownSymbols]
,{ParallelMap::subpar,ParallelEvaluate::subnopar}]]
SetAttributes[SuperFullSimplify,Listable];

Now, applying it to our last problem in the question, which was

SuperFullSimplify[(E^(-I x) y z + (1 + E^(I y)) (x + y) z)/z, z != 0]
(* ==> E^(-I x) y+(1+E^(I y)) (x+y) *)

, we get the desired result.

There are some modifications in comparison to VOISimplify:

• Instead of permutations of the variables names, permutations of Unique[a] names are performed (this is what actually solves the above problem);

• Automatic variables detection from the expression to be simplified (in VOISimplify they need to be specified);

• Added the possibility of setting any of the options that appear in FullSimplify: Assumptions, ComplexityFunction, ExcludedForms, TimeConstraint, TransformationFunctions and Trig;

• It is Listable as is FullSimplify;

• It executes the FullSimplify calls of each variables names permutation in parallel, so it is much faster;

The Quiet messages were included because Mathematica does not allow ParallelMap and ParallelEvaluate inside for example a ParallelTable, as they are parallelizations inside parallelizations.

Please feel free to point any problems with the code and to post other answers as alternative/optimized simplification functions.