Hi Henrik, thank you for your reply,

I won't necessarily always want to sum over all of the integers. I tried the code you suggested and the only result I get is: $\sum _{i=-\infty }^{\infty } b(i) \delta _{i,k}$. I also added the following line of code:

TeXForm[Simplify[myValue /. {n0 -> -Infinity, n1 -> Infinity}]]

And I still don't get the simplification, that is $\sum _{i=-\infty }^{\infty } b(i) \delta _{i,k}$. It would be helpful if Mathematica were able to do simple simplifications like this. The actual simplification I wanted to make was not this one, but it partly illustrates the point.

It seems the Kronecker delta accepts non-integer values, so I also tried to specify that $k$ had to be an integer, but it does not work either:

mySum = Sum[a[i] b[i], {i, n0, n1}]
myValue = D[mySum, a[k]]
myValue /. {n0 -> 1, n1 -> n}
Simplify[myValue /. {n0 -> 1, n1 -> n}, 
 k >= 1 && k <= n && Element[k, Integers]]

outputs $\sum _{i=1}^n b(i) \delta _{i,k}$

Hi Guillaume,

Indeed, those Kronecker deltas should be absorbed if there is enough information to make sure that the indices are in the proper ranges to guarantee coincidences. We are working on this problem, but it will take a bit more time to be in the system.

In the meantime, there are some tricks that you can use in simple cases. For example let us build the simplifyDelta function:

restrictedSum[e_, {{a_, ___}}, a_] := e;
restrictedSum[e_, {l___, {a_, ___}, r___}, a_] := Sum[e, l, r];

simplifyDelta[expr_] := expr //. {
    HoldPattern[Sum[e_ KroneckerDelta[a_, b_], inds__]] :> restrictedSum[ReplaceAll[e, a -> b], {inds}, a] /; ! FreeQ[e, a],
    HoldPattern[Sum[e_ KroneckerDelta[a_, b_], inds__]] :> restrictedSum[ReplaceAll[e, b -> a], {inds}, b] /; ! FreeQ[e, b]
    };

Now take for example a case with two sums:

mySum = Sum[a[i] m[i, j] b[j], {i, 1, n}, {j, 1, n}]

and take a second derivative, so we get two deltas:

In[]:= D[mySum, a[k], b[l]]
Out[]= Sum[KroneckerDelta[i, k] KroneckerDelta[j, l] m[i, j], {i, 1, n}, {j, 1, n}]

In[]:= % // simplifyDelta
Out[]= m[k, l]

Of course, you need to avoid repetition of symbols (both in indices and in names of indexed objects). The eventual algorithm in WL will handle all these things automatically.

Let me finally point out that there are several powerful Wolfram Language packages to handle indexed objects, and probably one of them can help you already. See for example xAct (www.xact.es).

Is this solved now? I have a similar problem where if I define

W = Sum[u[c[x, t + a, a], l[x, t + a, a]], {x, 1, N}]
dWdc = FullSimplify[D[W, c[y, a + t, a]], N >= y && y >= 1 && y \[Element] Integers ]

I still get Delta[x,y] in the output. What am I doing wrong?