Proper way to simplify integral result in Mathematica given integer constraints

While I'm late to the party, no one has given a complete solution, thus far.

Sometimes, it pays to understand the integrand better before you integrate. Consider,

ef = TrigReduce[
    Cos[(Pi x)/2]^2 Cos[((2 n + 1) Pi x)/2] Cos[((2 m + 1) Pi x)/2]]/.
  Cos[a_] :> Cos[ Simplify[a, Element[{m,n}, Integers] ] ]

which returns

(2 Cos[(m - n) Pi x] + Cos[(1 + m - n) Pi x] + Cos[(1 - m + n) Pi x] + 
 Cos[(m + n) Pi x] + 2 Cos[(1 + m + n) Pi x] + Cos[(2 + m + n) Pi x] )/8

where each term has the form Cos[q Pi x] with integral q. Now, there are two cases to consider when integrating Cos[q Pi x] over -1 to 1 (where q is integral): q == 0 and q != 0.

Case q = 0: This is a special case that Mathematica misses in the general result, as it implies a constant integrand. (I'll often miss it, also, when doing this by hand, so Mathematica isn't entirely to blame.) So, the integral is 2, in this case.

Strictly speaking, this isn't true. When told to integrate Cos[ q Pi x ] over -1 < x < 1, Mathematica returns

2 Sin[ Pi q ]/( Pi q )

which is 0 except when q == 0. At that point, the function is undefined in the strict sense, but Limit[Sin[x]/x, q -> 0] == 1. As the singularity at q == 0 is removable, the integral is 2 when q -> 0. So, Mathematica does not miss it, it is just in a form not immediately recognized.

Case q != 0: Since Cos[Pi x] is periodic with period 2, an integral of Cos[q Pi x] from x == -1 to x == 1 will always be over q periods. In other words,

Integrate[ Cos[q Pi x], {x, -1, 1}, 
  Assumptions -> (Element[ q, Integers ] && q != 0) ] == 0

Taken together, this means

Integrate[ Cos[q Pi x], {x, -1, 1}, Assumptions -> Element[ q, Integers ] ] == 
Piecewise[{{ q == 0, 2 }, { 0, q!=0 }}]

Using this, we can integrate the expanded form of the integrand via

intef = ef /. Cos[q_ Pi x] :> Piecewise[{{2, q == 0}, {0, q != 0}}] // 
 PiecewiseExpand 

which admits non-integral solutions. To clean that up, we need to reduce the conditions to only those that have integral solutions, and we might as well simplify as we go:

(Piecewise[{#1, 
    LogicalExpand[Reduce[#2 , {m, n}, Integers]] // 
     Simplify[#] &} & @@@ #1, #2] & @@ intef) /. C[1] -> m

\begin{Edit}

To limit confusion, internally Piecewise has the structure

{ { { value, condition } .. }, default }

In using Apply (@@), the condition list is the first parameter and the default is the second. To process this, I need to simplify the condition for each value, so then I use the second short form of Apply (@@@) on the condition list so that for each value-condition pair I get

{ value, simplified condition }

The simplification process uses Reduce to restrict the conditions to integers, LogicalExpand to help eliminate redundancy, and Simplify to limit the number of terms. Reduce internally uses the arbitrary constant, C[1], which it sets as C[1] == m, so we set C[1] back to m to complete the simplification

\end{Edit}

which gives

Piecewise[{
 {3/4, (1 + n == 0 || n == 0) && (1 + m == 0 || m == 0)},
 {1/2, Element[m, Integers] && 
       (n == m || (1 + m + n == 0 && (m <= -2 || m >= 1)))},
 {1/4, (n == 1 + m || (1 + n == m && (m <= -1 || m >= 1)) || 
       (m + n == 0 && (m >= 1 || m <= 0)) || 
       (2 + m + n == 0 && (m <= -1 || m >= 0))) && 
       Element[m, Integers]},
 {0, True}
}

as the complete solution.

Another Edit: I should point out that both the 1/2 and 1/4 cases include the values for m and n in the 3/4 case. It appears that the 3/4 case may be the intersection of the other two, and, hence, their sum. (I have not done the calc out, but I strongly suspect it is true.) Piecewise evaluates the conditions in order (I think), so there is no chance of getting this incorrect.

Edit, again: The simplification of the Piecewise object is not as efficient as it could be. At issue is the placement of the replacement rule C[1] -> m. It happens to late in the process for Simplify to make use of it. But, if it is brought inside the LogicalExpand and assumptions are added to Simplify

(Piecewise[{#1, 
    LogicalExpand[Reduce[#2 , {m, n}, Integers] /. C[1] -> m] // 
     Simplify[#, {m, n} \[Element] Integers] &} & @@@ #1, #2] & @@ intef)

then a much cleaner result is produce

Piecewise[{
 {3/4, -2 < m < 1 && -2 < n < 1}, 
 {1/2, (1 + m + n == 0 && (m >= 1 || m <= -2)) || m == n}, 
 {1/4, 2 + m + n == 0 || (m == 1 + n && m != 0) || m + n == 0 || 1 + m == n},
 {0, True}
}]