Mathematica Stack Exchange is a question and answer site for users of Mathematica. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

How can I get Mathematica to simplify the following expression

n Log[a] + m Log[b] - m Log[a + b] - n Log[a + b]


Log[ a^n b^m (a + b)^(-m - n)] ?

I've tried various methods without any luck including: -

FullSimplify[ n Log[a] + m Log[b] - m Log[a + b] - n Log[a + b], { a + b > 0 } ]

Perhaps I'm not including enough assumptions or Mathematica doesn't consider this to be a simplification ? It would be nice to have a solution that doesn't require pattern matching.

share|improve this question
In general Log[a^n] does not equal n*Log[a]. Take for instance Log[(-1)^2]. However, MMA knows that Assuming[{n > 0, m > 0, a > 0, b > 0}, FullSimplify[n Log[a] + m Log[b] == Log[a^n b^m]]] is True. So, these assumptions should be sufficient, but I cannot let it make the simplification itself. – Sjoerd C. de Vries Apr 4 '13 at 22:23
This Q&A seems to be a bit overlooked. The OP there wants to do things the other way around, i.e. go from a Log of a product to the sum of Logs. It is a subjective matter what a simplification is, so I like Artes answer here below. The OP in the link uses something similar. The answer in the link by wolfies just points to proprietary software, but can possibly provide some (professional) context. The answer in the link by Andre also seems great. – Jacob Akkerboom Apr 5 '13 at 9:39
up vote 8 down vote accepted

Let us introduce the function to transform the logarithm:

    collectLog[expr_] := Module[{rule1, rule2, a, b, x},
   rule1 = Log[a_] + Log[b_] -> Log[a*b];
   rule2 = x_*Log[a_] -> Log[a^x];
   (expr /. rule1) /. rule2 /. rule1 /. rule2

This is your expression:

expr = (n Log[a] + m Log[b] - m Log[a + b] - n Log[a + b]);

Let us first simplify it, and then apply to it the collectLog function:

    expr2 = Simplify[expr, {a > 0, b > 0}, 
   TransformationFunctions -> {Automatic, ComplexExpand}] // 

The result is

Log[a^n b^m] + Log[(a + b)^(-m - n)]

Let us apply the collectLog once more:

expr2 // collectLog

The result is:

Log[a^n b^m (a + b)^(-m - n)]


To answer the recent question of bszd: if a function with multiple Logs may be designed.

It can be done in a more simple way. If one has a lengthily expression with logarithms of the sort that might be simplified by collection, the function Nest may do the job:

 Nest[collectLog, expr, Length[expr]]

The answer is:

Log[a^n b^m (a + b)^(-m - n)]

If it is only a part of expression that, however, contains multiple logarithms to be collected, the function

collectAllLog[expr_] := Nest[collectLog, expr, Length[expr]];

may be mapped onto this part.

Finally, to complete this one may need to do the opposite operation: to expand the logarithmic expression. One way to do this would be to use the following function:

    expandLog[expr_] := Module[{rule1, rule2, a, b, x},
   rule1 = Log[a_*b_] -> Log[a] + Log[b];
   rule2 = Log[a_^x_] -> x*Log[a];
   (expr /. rule1) /. rule2


expandAllLog[expr_] := Nest[expandLog, expr, Depth[expr]]

For example,

expandAllLog[Log[a^n b^m (a + b)^(-m - n)]]


n Log[a] + m Log[b] + (-m - n) Log[a + b]

as expected.

share|improve this answer
This looks very good. Is there any easy way I can allow multiple arguments for rule1, i.e. rule1 = Log[a_] + Log[b_] + Log[]... -> Log[a*b*...]? – bsdz Apr 6 '13 at 14:27
@bsdz, Please have a look at the part I added to the answer. – Alexei Boulbitch Apr 8 '13 at 7:38
Perfect - that's exactly what I was looking for with the added benefit it can be applied in other situations too. Thanks! – bsdz Apr 8 '13 at 21:42

I know, I know: Now someone will ask why. Anyway:

FullSimplify@Log@Exp[n Log[a] + m Log[b] - m Log[a + b] - n Log[a + b]]

(* Log[a^n b^m (a + b)^(-m - n)] *)
share|improve this answer
Short and sweet. I mean that. Not like when my HS track coach would say it (which roughly translated to "I'm trying to make you puke this afternoon"). – Daniel Lichtblau Apr 4 '13 at 23:01
That's great. Shall test it tomorrow. Thank you – bsdz Apr 4 '13 at 23:04
Simplify works, too (in place of FullSimplify). – Michael E2 Apr 5 '13 at 0:19
Why does this work? :^) – Mr.Wizard Apr 5 '13 at 8:08
@bsdz It was a joke ... – Dr. belisarius Apr 6 '13 at 11:41

Well, although late, here's an answer using ReplaceRepeated (//.).

Let's define two replacement rules to take us back and forth.

logrule = {Log[x_] + Log[y_] :> Log[x y], n_ Log[x_] :> Log[x^n]}

revlogrule = {Log[x_ y_] :> Log[x] + Log[y], Log[x_^n_] :> n Log[x]}

Now here's your problem

expr = n Log[a] + m Log[b] - m Log[a + b] - n Log[a + b]

using the logrule we can simplify your expression:

expr //. logrule

Which gives:

Log[a^n b^m (a + b)^(-m - n)]

Now let's go back to the original expression using revlogrule

Log[a^n b^m (a + b)^(-m - n)] //. revlogrule // Expand

n Log[a] + m Log[b] - m Log[a + b] - n Log[a + b]


You can also use FullSimplify with TransformationFunctions as follows. First define the transformation you desire to be applied:

tfunc[x_] := x /. logrule


FullSimplify[expr, TransformationFunctions -> {Automatic, tfunc}]

Which gives as before:

Log[a^n b^m (a + b)^(-m - n)]

share|improve this answer
I don't believe you need the rule Log[x_] - Log[y_] :> Log[x/y] as I think this should be handled by Log[x_] + Log[y_] :> Log[x y]. Likewise Log[x_/y_] :> Log[x] - Log[y]. There can be surprises but I don't think that particular case applies here. (+1) – Mr.Wizard Sep 23 '13 at 11:30
@Mr.Wizard, Ah yes, fixed. Thanks. – RunnyKine Sep 23 '13 at 11:51
By the way, if this account is yours you might request a merge. – Mr.Wizard Sep 24 '13 at 14:57
@Mr.Wizard. Thanks a lot!. I've been looking for a way to do that. – RunnyKine Sep 24 '13 at 18:24

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

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