What's the difference between Inactive and HoldForm?

Question

In version 10, Mathematica not only added Inactive / Activate but also highlighted this change in the "New in 10" page (in Core Language Enhancements). Thus, I suppose it should be something useful. However, I didn't understand in which sense it is better than the good old Hold (HoldForm) / ReleaseHold mechanism. I noticed a few differences, but all of those are minor:

(1) Inactive objects are printed in a lighter color. HoldForm objects are printed in normal color.

(2) There is an IgnoringInactive function to include inactive objects into pattern matching.

It would be nice to hear if there are more important differences.

Answer 1

Updated

Both Hold and Inactive block evaluation; the key difference is that Inactive is meant to be wrapped around heads rather than a whole expression. Inactivate does this.

Inactivate[1 + 2 + 3 * 4 ^ 5 ] // FullForm

Inactive[Plus][1, 2, Inactive[Times][3, Inactive[Power][4, 5]]]

It is of course possible to use Inactive directly, and it will behave like any symbol with holding attributes.

Inactive[1 + 2 + 3 * 4 ^ 5] // FullForm

Inactive[Plus[1, 2, Times[3, Power[4, 5]]]]

But in general there is no reason to use it this way. Note that while Activate and ReleaseHold are comparable, there is no analog to Inactivate. The point is to use these auxiliary functions.

Because Inactivate wraps heads, it can accept an optional second argument constraining which heads to inactivate.

Inactivate[1 + 2 + 3 * 4 ^ 5, Plus] // FullForm

Inactive[Plus][1, 2, 3072]

Activate can similarly accept an optional second argument.

Inactivate[1 + 2 + 3 * 4 ^ 5];
Activate[%, Power] // FullForm

Inactive[Plus][1, 2, Inactive[Times][3, 1024]]

Another interesting consequence of using Inactivate is that atomic symbols will get evaluated.

Hold @ {$WolframUUID}

Hold[{$WolframUUID}]

Inactivate @ {$WolframUUID}

{"0e2497dc-9281-48f3-8e84-14b5e2587446"}

Answer 2

One difference is that NDSolve directly supports Inactive. It can be used to specify operators such as divergence ($\nabla\cdot$) without automatically evaluating them to components. This is described here.

Answer 3

Although mfvonh's answer is a nice summary of Inactive formal properties, I think it misses several important points, which are both shown in the "Scope" and "Applications" section of the documentation. For me the main point seems to be (2), as I don't know how this could be achieved using Hold.

1) Inactive can be used to illustrate formal mathematical identities, e.g.,

Table[Block[{e = Inactivate[n + m]}, e == Activate[e]], {n, 0, 3}, {m,
 0, 3}] // Grid // TraditionalForm

2) It can be used in formal mathematical manipulations (as hinted at by Szabolcs' answer), e.g.,

D[Inactive[Integrate][f[x], {x, a[x], b[x]}],x]
(*-f[a[x]] Derivative[1][a][x] + f[b[x]] Derivative[1][b][x]*)

3) It can be used for easy programmatic code transformation, as Inactivate automatically wraps around all heads:

 def = Inactivate[for[f_, max_] := For[x = 1, x < max, x++, Print@x]];
 def/.Inactivate[For[i_ = init_, i_ < max_, i_++, body_] :> Do[body, {i, init, max}]]
 (*forSquares[f_,max_]:=Do[Print[f[x^2]],{x,1,max}]*)

So the use cases are quite different from the ones of Hold/ReleaseHold. I don't think (2) could be easily achieved with Hold, and (3) is definitely more elegantly solved by using Inactivate.

Answer 4

I think the basic answer to your question is:

1) If you want absolute control over revaluation, nothing beats good old HoldComplete. It will be there to the end of time.

2) Inactive meant for much more targeted/slippy applications. As such, it only wraps heads, not all arguments (as already noted by mfvonh). You can control which heads get inactived. And math is allowed to occur when there is an unambigous answer to an operation, which absolutely cannot happen with Hold. My personal favourite:

In[2]:= Curl[Inactive[Grad][f[x, y], {x, y}], {x, y}]
Out[2]= 0

In keeping with these applications, Inactivate ignores certains heads but default, most notably List. This way, the strucutre of your data is unchanged and tensorial operations can be performed--very important in NDSolve. The basic idea is Inactive[f] represents an inactive form of a desired operation, not some held expression which will be modified on manually.