Possible to determine equivalence of hash codes from different hashing functions? Let $H_{1}(x)$, $H_{2}(x)$, ..., $H_{n}(x)$ be a list of $n$ secure one-way hash functions such that for a given input $x$ each $H_{i}(x) \neq H_{j}(x)$ when $i \neq j$.  Give one hash function to each of $n$ people.  No person should be able to reproduce the output of any other person's hash function.  

For any inputs $x,y$ with $x \neq y$, is it possible to define a comparison function $F$ such that $F(H_{i}(x),H_{j}(x)) = true$ and $F(H_{i}(x),H_{j}(y)) = false$?

In other words if each person creates hash codes of the same inputs using different secure one-way hash functions, can I tell what hash codes were derived from the same input?
Actually, if you define the $H_i$ functions properly, it can be done.

I'll make the simplifying assumption that we can treat the $H_i$ and $F$ functions as Oracles (that is, you're not allowed to look inside their implementation); I believe that it's still possible without that assumption (but the solution may be more complex).

For our primitives, we'll use FF1 with a secret key; and define:

$$H_i(x) = FF1_{key}( SHA256(x) || i )$$

This meets all the requirements of a secure hash function (e.g. it is collision resistant if we assume SHA256 is); in addition, the holder of $H_i$ cannot use it as a Oracle to compute $H_j$ for $i \ne j$ (as they don't know the $key$)

And, we can define a function $F$ that uses the secret key to decrypt both encrypted hashes, and compares the SHA256 values.  This will correct tell if the two original messages where the same (unless we happen apon a collision in SHA256)