It seems like Mathematica immediately evaluates the expression Sqrt@I to (-1)^(1/4). I'm trying to use Simplify with my own ComplexityFunction f in such a way, that Simplify[Sqrt@I] returns Sqrt@I, which (in my opinion) is the simpler expression. Hence, I've defined the following f:


Testing it yields the expected results:




Now, when I call Simplify[Sqrt@I, ComplexityFunction->f] it still returns (-1)^(1/4). I believe this is due to the fact that after the simplification (which should return Sqrt@I), the expression is in turn evaluated to (-1)^(1/4). Can I define f in such a way that this last evaluation is not performed? Can I use HoldForm to achieve this?

  • $\begingroup$ A side note: (f@#&) is redundant; you can use simply f. $\endgroup$
    – Mr.Wizard
    Commented Jan 21, 2013 at 11:41
  • $\begingroup$ Okay, thanks. I wasn't sure if the head of the right side of ComplexityFunction needed to be Function. $\endgroup$
    – einbandi
    Commented Jan 21, 2013 at 11:44

1 Answer 1


I believe your function works correctly but the automatic transformation functions used by Simplify lack a rule that converts (-1)^(1/4) into Sqrt[I]. Also, your observation that the reverse transformation happens automatically is correct, therefore even with the right transformation function you do not get the result you want. However, you can Hold the expression to prevent this.

Attributes[f] = HoldAll;
f[expr_] := StringLength @ ToString @ HoldForm @ expr

tf = # /. HoldPattern[(-1)^(1/4)] :> Sqrt @ I &;

Simplify[Hold[(-1)^(1/4)], ComplexityFunction -> f, TransformationFunctions -> tf]

I used a transformation rule that explicitly performs the replacement you desire. It also operates inside of Hold which the default transformations do not. This isn't particuarly helpful I fear but it does illustrate that with the right ComplexityFunction and TransformationFunctions settings Simplify can perform the operation you want. Crafting those functions may be difficult however.

I took another look at this, and it seems that the custom ComplexityFunction is not needed here. I also found that (-1)^(1/4) may be represented in at least two different internal forms which illustrates the complexity of crafting your own rules. (In practice if any transformations can be done with built-in functions rather than manual pattern matching they should be done that way.)

auto = Replace[#, x_ :> With[{eval = FullSimplify[x]}, eval /; True], -1] &;
tf = # /. HoldPattern[(-1)^(1/4) | (-1)^Rational[1, 4]] :> Sqrt[I] &;

expr = Hold[1/(3 (1 + x)) - (-1 + 2 x)/(6 (1 - x + x^2)) +
            2/(3 (1 + 1/3 (-1 + 2 x)^2)) + (-1)^(1/4)];

Simplify[expr, TransformationFunctions -> {auto, tf}]
Hold[Sqrt[I] + 1/(1 + x^3)]

Notice that in the rule auto I am calling FullSimplify to access the default rules, and I am using the Trott-Strzebonski method for In-Place Evaluation to make these apply inside Hold.

  • $\begingroup$ Thank You! That's pretty much what I wanted to hear. I didn't know how to use TransformationFunctions correctly. $\endgroup$
    – einbandi
    Commented Jan 21, 2013 at 12:05
  • $\begingroup$ @einbandi I updated my answer with an example that I hope you will find more practical. $\endgroup$
    – Mr.Wizard
    Commented Jan 21, 2013 at 12:35

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.