permutation symmetric hash function I'm searching for good hash-function for N-dimensional vector of M-bit integer numbers with a property that any permutation of the coordinates gives the same result.
e.g. $ h(x,y,z) = h(x,z,y) = h(y,x,z) = h(y,z,x) = h(z,x,y) = h(z,y,x) $
by good hash-function I mean following:


*

*good avalanche properties - There is minimum correlation between values of arguments and values of resulting hash. To avoid mapping of similar arguments to the same hash.

*good statistical properties - results are uniformly distributed. ( to minimize statistical probability of collision = mapping different arguments to the same hash )

*fast to compute on computer - i.e. use just operation like bitwise and, or, xor, not, bit-shift, aritmetical addition, subtraction, multiplication, maybe modulo



NOTE 1
I certainly do not require perfect hash function (which is bijective;  without any collisions ) since I want to use it for dimensionality reduction. The resulting hash should has less bits than the original vector.

NOTE 2
hash function like 
$h(x,y,z)= x + y + z$
$h(x,y,z)= x\ \mathrm{XOR} \ y\ \mathrm{XOR}\ z$
has permutation symmetry, but does not have very good statistical properties and avalanche properties. They have too much correlation between arguments and results, therefore for some sets of arguments gives too much collisions. 
 A: Just hash each element independently using the same hash function, and take the sum. 
A: The obvious solution is to sort the components and then use any of-the-shelf hashing function. By sorting them you effectively map the vector space into itself in a way that is invariant under permutations of the components.
Actually applying any mapping $\phi$ that is invariant under permutation combined with any hash function $\chi$ (or any other function) would result in a (hash) function that is invariant under permutations.
A: Taking the sum, as the answer by user1502040 suggests, is a bad idea:

*

*It will mean that the hash value grows with the size of the list, but usually a fixed size hash is desirable

*It will lead to more collision due to the Central Limit Theorem.

Here's a discussion on how python's frozenset solves the problem: https://stackoverflow.com/questions/20832279/python-frozenset-hashing-algorithm-implementation
Essentially, keep xoring with the hashes of the items with some multiply-shifts thrown in.
Other discussions:

*

*https://crypto.stackexchange.com/questions/54544/how-to-to-calculate-the-hash-of-an-unordered-set
