How to detect changes in data while preserving confidentiality (under constraints)? Suppose party $A$ has two pieces of data, $X$ and $Y$, either of which may change separately, or they may change together.

Given the following constraints:


$A$ knows its current $X$ and $Y$ but has no further knowledge about its previous or future values, nor can it store anything else
There is only one-way communication, from $A$ outward
$X$ can be publicly shared (yet doesn't need to be), but $Y$ needs to be strictly confidential
$Y$ comes from a limited set $S$ of possible values; therefore even from a hash $H(Y)$ it would, in theory, be possible for $Y$ to be determined (see 6.) $X$, in contrast, is infeasible to brute-force.
$A$ does not know $S$
$A$'s algorithm/method $M(X,Y)$ cannot be kept secret


Is there a way for party $B$, receiving messages from $A$, to track exactly which of the values changed?

Changes in just $X$ are trivial, because $X$ could be transmitted in the clear.

Changes in $Y$ are also easy if and only if it is known that $X$ has not changed. In that case $A$ would not send $X$ in the clear, but $H(X)$ and $H(Y||X)$. This way, $B$ knows that if $H(X)$ has not changed, but $H(Y||X)$ has, the change must have been because of $Y$. By not knowing the actual $X$ ($B$ doesn't need to), $B$ can't brute-force $Y$.

However, when $X$ did change, $H(Y||X)$ changes too, at least because of $X$. Yet, $B$ needs to know whether $Y$ also changed, without being able to brute-force it. If $H(Y)$ were sent as well, $B$ could then try different $Y$s and see if $H(Y)$ matches, because it knows the design of $A$.

The question therefore mostly concerns detecting changes in $Y$ when it is known that $X$ has changed. I fear this is theoretically impossible, but I'd like some extra eyes on the problem to either confirm that or (preferably) prove otherwise.
I'm going to try to make a handwavy argument that this problem doesn't have any great solution.  Criticisms are welcome!  A major assumption here is that my definitions are general enough to cover any possible solution to your problem.

Suppose there exists a scheme consisting of three deterministic algorithms $\operatorname{Broadcast}(X, Y)$, $\operatorname{CompareX}(B_1, B_2)$ and $\operatorname{CompareY}(B_1, B_2)$.  $\operatorname{Broadcast}$ is run by party $A$ and accepts $X$ and $Y$, outputting some "broadcast" value $B$.  $\operatorname{CompareX}$ and $\operatorname{CompareY}$ compare two broadcast values to determine if they were generated from the same $X$ or $Y$ values, respectively, and output $0$ when matching or $1$ when different.

Suppose a broadcast value $B_0$ is received by the attacker, who wishes to determine the secret value $Y$ from which it was generated.  The attacker can use the public algorithms $\operatorname{Broadcast}$ and $\operatorname{CompareY}$ to brute force the $Y$ value as follows:


Choose some arbitrary fixed value $x$ for use as an input to $\operatorname{Broadcast}$.
For each $y$ where $y$ is a guess for $Y$, call $\operatorname{CompareY}(\operatorname{Broadcast}(x, y), B_0)$.  Halt and output $y$ iff $\operatorname{CompareY}$ outputs $0$.


This suggests the option of making $\operatorname{Broadcast}$ or $\operatorname{CompareY}$ slow.  Consider the following scheme:


$\operatorname{Broadcast}(X,Y) = (X, \operatorname{PBKDF}(Y))$, where $\operatorname{PBKDF}$ is a password-based KDF such as scrypt, but using a fixed salt.
$\operatorname{CompareX}$ and $\operatorname{CompareY}$ are simply an equality check on the appropriate field.


If $S$ (the set of possible $Y$ values) is large and $\operatorname{PBKDF}$ is sufficiently slow, this might afford a modest level of security.