Question

(I made some changes…)

very often I want to simplify the function’s argument, or apply a pattern to it, eg. I want to change:

Exp[a(b+c)]

into

Exp[a b + a c]

simple pattern doesn’t help:

Sin[a(b+c)] /. Sin[aaa_] -> Sin[Expand[aaa]]

gives again

Sin[a(b+c)]

However, with functions other than Simplify / Expand it seems to do what I expect:

Sin[a (b + c)] /. Sin[aaa_] -> Sin[f[aaa]] 

gives

Sin[  f[a(b+c)]  ]

My usual solution was to use 2 patterns and Hold:

(Exp[a(b+c)] /. Exp[aaa_] -> Exp[Hold[  Expand[aaa]  ]] ) /. Hold[xxx_] -> xxx

which results in

E^(a*b + a*c)

The disadvantage of this method is that code gets more complicated than it’s neccesary.

MY REAL LIFE EXAMPLE is:

ppp2 = 
 ( ppp1  
    /. { ExpIntegralEi[aaa_] -> 
           ExpIntegralEi[Hold[aaa /. { u2 -> 0, w2 -> 0, u3 -> x, w3 -> x}]], 
         Log[aaa_] -> 
           Log[Hold[aaa /. {u2 -> 0, w2 -> 0, u3 -> x, w3 -> x}]]
       }
 ) /.  Hold[xxx_] -> xxx;

where ppp1 is a long sum of terms containing u2, w2, u3, w3 and so on. I want to change the values of u, w2… ONLY in ExpIntegral and Log.

My other solution is a function:

ExpandArgument[expr_, what_] := Module[{list},
  list = Extract[expr, Position[   expr, what[_]   ]];
  list = Map[Rule[#, what[Expand[   #[[1]]   ]]] &, list];
  Return[expr /. list]
]

The function I wrote can be easily generalised to make it possible to use not only Expand but also Simplify and so on:

ApplyToArgument[expr_, ToWhat_, WhatFunction_] := Module[{list},
  list = Extract[expr, Position[   expr, ToWhat[_]   ]];
  list = Map[Rule[#, ToWhat[WhatFunction[   #[[1]]   ]]] &, list];
  Return[expr /. list]
]

For example:

ApplyToArgument[Sin[a (b + c)], Sin, Expand]

gives

Sin[a b + a c]

and

ApplyToArgument[Sin[a b + a c ], Sin, Simplify]

gives

Sin[a (b + c)]

This solution is easy to read but needs some refinement before being applied to many-argument functions (and I need these functions).

I guess I’m missing something fundamental about patterns in mathematica… How should I apply patterns to arguments of functions? (Or simplify, expand, etc. them)

Thanks a lot!

Answer 1

For the first part of the question, you could consider using RuleDelayed:

Sin[a (b + c)] /. Sin[aaa_] :> Sin[Expand[aaa]]

gives

Sin[a b + a c]