My problematic:

I have pool of bitfields of same length

ex:

A1 = 0000 1110 1010 0110 0111 ...

A2 = 1011 0111 1011 1001 1110 ...

...

An = 1110 0110 1110 0000 1000 ...

These bitfields are not random and should be carefully generated.

Someone pick up 2 bitfields. and can mix these two bitfields and construct a new bitfield by, for each bits,

choosing the value of the bit of the first or the second bitfield.

This will follow the following rule:

0 0 => 0

0 1 => 0 or 1

1 0 => 0 or 1

1 1 => 1

The problem is: are we able to retrieve one of the bitfield the user takes knowing the constructed bitfield?

For me, this is possible if we generate carefully the bitfields.

The message produced will have in any cases some immutable bits (when bits are same in the two bitfield). We can assume that in average, without generating

carefully the bitfield, 50% of the bits of the generated bitfield should be kept.

for the rest, almost 50% of the bits should be on the right place whatever the randomization.

So, despite mixing, we have 75% of the bits of one of the bitfield we did used. I assume that with a correct redondancy code, we can retreive the original

bitfield.

Now, the question is: is it possible to generalize this problem for more than 2 bitfields. Means that the user can, for each bit select the bit value in one

on n bitfield?

My intuition is: we should be able... The generation of the bitfield is very important to achieve our goal. Does somebody have an idea?