Simplify expressions with Log

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}] // 
  collectLog

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)]

Done.

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
   ];

and

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

For example,

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

yields

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

as expected.

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)] *)

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]

EDIT

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

tfunc[x_] := x /. logrule

Then:

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

Which gives as before:

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