how to simplify symbolic integration

Question

The following is the code:

    In[3]:= Simplify[Integrate[f[x]*c, {x, a, b}]/c, Assumptions -> c > 0]

    Integrate[c f[x], {x, a, b}]
    ----------------------------
                c

but obviously the right answer should be:

    Integrate[f[x], {x, a, b}]

how to solve it without placing c outside the integrate function?

Answer 1

You can tell Mathematica that it may move multiplicative constants out of the integral by defining the function

moveconst[x_]:=(x /.
  Integrate[factor_ expr_, {var_, min_, max_}] /; FreeQ[factor, var] :>
  factor Integrate[expr, {var, min, max}])

and then using

Simplify[Integrate[f[x]*c, {x, a, b}]/c, Assumptions -> c > 0,
         TransformationFunctions->{Automatic, moveconst}]
(*
==> Integrate[f[x], {x, a, b}]
*)

Note that Mathematica only uses the transformation if it really makes the expression simpler:

Simplify[Integrate[f[x]*c, {x, a, b}], Assumptions -> c > 0,
         TransformationFunctions->{Automatic, moveconst}]
(*
==> Integrate[c f[x], {x, a, b}]
*)

Here, moving the constant out of the integral would not have simplified the expression, therefore Mathematica doesn't do it.

Answer 2

There is no way to do exactly what you want because an assumption can't be used to tell Mathematica that there exists an indefinite integral of the unknown function f[x]. See for example this MathGroup post.

However, you can get almost what you need if you define the indefinite integral yourself in the following way:

f /: Integrate[f[x_], x_] := ff[x]

This declares ff[x] as the anti-derivative of f[x]. Now we can get somewhere with the symbolic integration:

Simplify[Integrate[c f[x], {x, a, b}]/c]

-ff[a] + ff[b]

By using the delayed assignment (TagSetDelayed) for the indefinite integral, it's also possible to use other integration variables, as in

Simplify[Integrate[c f[t], {t, a, b}]/c]

-ff[a] + ff[b]

Edit

The advantage of this approach is that it also helps with other simplifications whose pattern you may not have foreseen at the outset. If you follow the pattern-matching micromanagement approach of the other answers, you'd have to introduce new patterns for new cases. For example, I can also simplify the integral:

Simplify[Integrate[c + f[x], {x, a, b}]]

(-a + b) c - ff[a] + ff[b]

And one could go on...

Answer 3

This is quite probably ill-advised, but

Clear[mysimp];
mysimp[Integrate[c_Symbol*f_[x_], {x_, a_, b_}]] := 
  c*Integrate[f[x], {x, a, b}];
mysimp[h_[x__]] := Map[mysimp, h[x]];
mysimp[x_?AtomQ] := x;
mysimp[Integrate[c*f[x], {x, a, b}]/c] // InputForm

Integrate[f[x], {x, a, b}]

These patterns are written quite specifically for your example, though. I don't expect this to be generally useful.