Distinguishing bit-strings

\label{sec:distinguished}

Let us model a particle as a string of bits: these bits encode all the information about the particle. Alternatively, we could think of the bits as representing a length of DNA or something (in this case, there would be two bits per base, or one “quit” per base). This is a contrived setup, difficult to realise in practice; but such a minimal model is useful for clarity.

Questions:

1. How much does it cost to write this information?

2. What is the cost of reading it?

3. What is the cost of comparing two strings with each other and noting discrepancies?

4. What is the meaning of temperature in this context?

5. What about errors?

Answers:

1. Note: from my (incomplete) derivation of Landauer’s Principle in section \ref{sec:LP}, I have decided that the following reasoning is wrong. But I don’t quite know why! I leave the following here for now, but my conclusion is that it may not cost as much to write definite information if the prior bit-distribution is not flat. Unfortunately, this means that everything that comes after might need adjusting. There must be some cost to writing information, because we are modifying blank DOF (bits) into new states, which necessarily deletes pre-existing information¹. This point seems to go unaddressed in the literature: writing information to an initially blank register increases the “entropy” (in the narrow sense of \(S=-\sum_ip_i\log_2p_i\) for a very long string – see section \ref{sec:stringS}) of the register, and so there’s no reason to require any dissipation. But here’s why I think it must be there nonetheless.

   • We don’t know a priori whether the writing process will result in a net increase or decrease of the string’s “entropy”. So, if we believe in cause-and-effect, and we accept that the end result is not known by the register until it has been realised, we should accept that heat dissipation takes place in the same way for each bit written. It is the result of physical processes, immutable by patterns in the outcome.

   • Another way of thinking of the problem is in terms of logical reversibility. A “reset all bits to zero” operation is irreversible because we cannot recover the original data after the operation. The same applies here: we would want our writing protocol to work regardless of the initial state of the register, so we always end up with the data we want in the register.

   • We are changing the physical state of a physical system by writing our data to the register.

   • One might think that we are taking an initial random distribution of bits on the register and making it a determined distribution (reproducible if we re-run the measurements on the particle under scrutiny). But we really have no idea about whether the pre-existing string was random or generated by some other deterministic process. Put another way, if all we have is the bit-string, we can only ever estimate the probabilities and correlations of the string’s generator; we can’t reconstruct the process by which that sting was made (unless we know what the process was and whether it is logically reversible).

   So even if the states are energy-degenerate, which can be arranged, the cost per bit written should be \(kT\ln2\), regardless of the initial state of the register.

2. In principle, there is no cost to reading information unless you want to remember it². If this is the case, see point 1.

3. Let us use an XOR gate; this takes two binary inputs, and outputs 0 if they are the same or 1 if they are different³.

   • Let the output be written to a register (not necessarily blank). This will require the expenditure of at least \(NT\ln2\) of work.

   • When the comparison is complete, all the 1s in the register are summed (e.g. using a carry-lookahead adder). The total is a measure of the difference between the two particles (note this loses information about where the differences were, but I don’t think that’s so interesting). Traditionally, these require writing of one extra bit per addition column, but I think we can ignore this for now as it’ll probably be much smaller than writing to the register with the XOR.

   Thus we find that more detailed comparison of the particles, where we inspect more bits, takes proportionally more energy. Specifically, to inspect \(N\) bits requires at least \(NT\ln2\) of energy.

5. Too much to tackle now – there is a vast literature on error correction. Presumably one just needs to work out how many extra erasures there are.

To do:

1. Answer question about temperature.

2. Derive energy to erase a bit as function of source entropy.