Invariants ("checksums", "hash") for collection of integers The sum of a collection of integers doesn't depend on the order of the integers and can detect the corruption of one element of the collection (but multiple elements can get corrupted without their sum changing).
What are other invariants for a collection of integers, preferably those that can detect the corruption of multiple elements (while ignoring any changes in the order in which the elements are processed to calculate the invariant)?
Constraints: Number of integers is known, say, 16 Million 8 Million to 20 Million. Integers in the collection need not be unique (so all could be 0). Integers fit in 25 bits (irrelevant if treated as signed or unsigned). Also, it suffices to detect an error (no need to correct it).
 A: I think Aaron Meyerowitz's comment is very on-point-- the OP probably needs to add some additional constraints to make the question non-trivial.  That said, in keeping with the spirit of the question, here's one perspective.
Let's make a few additional assumptions, hopefully in the spirit of the OP:

*

*There are $N$ items $x_1,...,x_N$, and $N$ is known.

*The items are non-negative.  (As Meyerowitz points out, this isn't really much of a restriction.)

Note that if we have a symmetric polynomial $p(x_1,...,x_N)$, then the order of the $x_i$ doesn't matter (i.e., the value of the polynomial is invariant).  We can now choose our favorite family of symmetric polynomials (e.g., the elementary symmetric polynomials), evaluate the first $k$ polynomials on our set, and use those values as our "hash".
Note that if the $x_i$ lived in some finite field instead of $\mathbb{Z}$, we essentially would be recreating BCH error-correcting codes.

EDIT
The OP's clarifications suggest a more concrete version of the above discussion.  It appears that we are trying to keep track of an unordered set $S$ of 25-bit strings, i.e., numbers in the range 0 to $2^{25}-1$; the size of the set is unknown but might plausibly be half the range.  In that case, we can represent $S$ very efficiently by a vector $v \in \mathbb{F}_{2}^{2^{25}}$ (i.e., a vector of $2^{25}$ bits), where the $i$-th bit is 1 if $i \in S$ and 0 otherwise.
Our problem then becomes one of considering error-detecting codes for $v$.
As suggested above, a $t$-error-correcting BCH code has distance $2t+1$ so can detect up to $2t$ errors.  (Note that an "error" in this encoding is either the insertion or removal of a number from $S$, so if we mutate one number into another, that counts as two errors: an insertion and a deletion.)
In practical terms, and using the notation on the BCH wikipedia page linked above, you'd use $q=2$, $c=1$, $m=26$, and if you store a hash of $\leq (2t+1)m/2$ bit corresponding to the syndrome of the BCH code, you'll be able to detect $\leq 2t$ errors.  If you were able to exclude a single element from $S$ (e.g., if the all-zero string never showed up), then you could reduce $m$ to 25 and save yourself a few bits.
In even more practical terms, if you're comfortable trading off some guarantee of correctness for much increased ease of implementation, you may prefer using a random code: construct $v$ as above, and generate $M$, a random $a \times 2^{25}$ matrix of bits.  Store $Mv$, which will be a string of $a$ bits.  This hash should perform nearly optimally as $a$ gets large enough (eventually beating the BCH code).
