# Can you recover the original vectors that, when summed together, achieved a particular criteria

I am wondering if it is possible to take the binary strings of length $$3$$ (tuples) whose sums have weight $$2$$ (i.e they have $$2$$ non-zero entries)(binary case, meaning they have two $$1$$'s entries) $$u \in \text{tuples}$$ $$v \in \text{tuples}$$ $$u + v \in \text{tuples of weight } 2$$ and then recover which original strings ($$u,v$$) summed together to give a vector of weight $$2$$?

The following code takes all the possible binary strings of length $$3$$ (tuples) and then adds every string to every other string (filter). I do this in order to find the positions in which those strings differ (because they are binary strings, a 1 in position i means that both strings differed in the $$i^{th}$$ position).

I then use the If[] function to see which resulting vectors from the filter have weight $$2$$.

However, what I would like to do would be to find a way to "reverse" this process and figure out which of the original tuples added together to give these vectors of weight 2 (two non-zero entries).

tuples=Tuples[{0,1},3]
filter=Flatten[Outer[Mod[Plus[##], 2] &, tuples, tuples, 1], 1]
distance2=If[Total[#] == 2, #, Nothing] & /@ filter

• Try Select[filter, Total[#] == 2 &] which gives the same result distance2 Sep 26 at 10:32
• That is certainly a cleaner way to get distance2, thanks Sep 26 at 11:37

Here is a solution that does not create all tuples, it only creates valid tuples.

Note that to get a digits of 0 in the result, the digits in the 2 initial lists must either be both 0 or both 1.

To get a digit of 1, the initial digits must be either 1,0 or 0,1.

With this we may create a function that takes a result list and returns pairs of possible initial lists.

getinitial[in_]:= Module[{t},
t= in /. {0 -> {{1, 1}, {0, 0}}, 1 -> {{1, 0}, {0, 1}}};
t = Flatten[Outer[Transpose[{#1, #2, #3}] &, Sequence @@ t, 1], 2]
]


We can apply this function on the possible result lists: {0,1,1},{1,0,1},{1,1,0}:

getinitial /@ {{0, 1, 1}, {1, 0, 1}, {1, 1, 0}} // MatrixForm It looks like $$u+v$$ is just BitXor[u,v] here, and since BitXor is its own inverse another possibility is:

sumPoss = Permutations[{1, 1, 0}] // Reverse;
tups = Tuples[{1, 0}, 3];
Outer[Join[{#2, BitXor[#1, #2]}] &, sumPoss, tups, 1] // MatrixForm


I reversed the output of Permutations to match @DanielHuber's matrix output: I do explicitly create all the {0,1} 3-tuples, so this may be bad.