Replacing a function in defined expressions

Question

I'm having a little trouble with substituting functions into an expression. A minimal example is as follows:

diffy := D[U[z], z];
Unevaluated[diffy]/. U[z] :> Exp[-I*k*z]
    Derivative[1][U][z]

Instead I want to do this:

Unevaluated[D[U[z], z]] /. U[z] :> Exp[-I*k*z]
    -I E^(-I k z) k

but obviously I can't do the latter because my practical "diffy" expression is a result of many steps and consists of many lines of functions and derivatives of U[z].

Is there a way Mathematica can take a function, substitute it into an expression such as "diffy" and evaluate it? I tried enclosing my expression above in "Evaluate[]" but that did not work.

Update: The solution provided works for the above prototype, but when I add another level, it all breaks down. This is a minimum example:

U0 := U[z];
diffy1 := Hold[D[U0, z]];
diffy1 /. U[z] :> Exp[-I*k*z] // ReleaseHold
    Derivative[1][U][z]

I have tried holding the first expression, releasing the hold in the definition of the second one and then holding again - and many other combinations of holding/releasing but nothing has worked so far. Is there a fundamental reason why this is not working? Maybe I'm not thinking of Mathematica correctly but I don't understand why this does not work immediately.

Answer 1

Based on your extended example I think you are going to need to change your fundamental approach to this problem, as it becomes too complicated to work out which parts should be evaluated and which should be held. (That is, for a general case.)

For the simpler example I recommend that you read How do I evaluate only one step of an expression? and my self-answer. Using step defined there we may write:

diffy := D[U[z], z];

step[diffy] /. U[z] :> Exp[-I*k*z] // ReleaseHold

-I E^(-I k z) k

(If you prefer you could also write: Unevaluated @@ step[diffy] /. U[z] :> Exp[-I*k*z])

This methodology breaks down however for your referential definition because nowhere is it specified which parts should and should not evaluate:

U0 := U[z];
diffy1 := D[U0, z];
step[diffy1] // FullForm

HoldForm[D[U0, z]]

For this particular example I presume you want only D to not evaluate, so you could Block it:

Block[{D}, diffy1 /. U[z] :> Exp[-I*k*z]]

-I E^(-I k z) k

If you always know which heads (functions) you wish to prevent from evaluating this is a fine method.

---

Evaluation by Context

Perhaps making only those substitutions described in definitions that exist in the Global` Context will have the effect that you desire. Please consider:

SetAttributes[evaluateGlobal, HoldFirst]

evaluateGlobal[expr_, supplemental_: {}] :=
  With[{values = {UpValues, NValues, OwnValues, DownValues, SubValues}},
    With[{rules = Flatten @ Outer[Apply, values, MakeExpression @ Names["Global`*"]]},
      Hold[expr] //. rules /. supplemental // ReleaseHold
    ]
  ]

This function allows either a one parameter input form, which will require manual holding:

U0 := U[z];
diffy1 := D[U0, z];

evaluateGlobal[Hold[diffy1]] /. U[z] :> Exp[-I*k*z] // ReleaseHold

-I E^(-I k z) k

Or a two parameter form to simplify its application for this use:

evaluateGlobal[diffy1, U[z] :> Exp[-I*k*z]]

-I E^(-I k z) k

Answer 2

Holding the pattern works:

diffy := Hold[D[U[z], z]]
held = diffy /. U[z] :> Exp[-I*k*z]

Edit for completeness:

held // ReleaseHold