And it's a good think that this transition is happening now, and not 10 years later when everyone is using bitcoins.

my point was...if we were doing this on 10 pentiums governments would crush us like a bug

as it stands we operate the most powerful computing effort that has ever existed

i don't know if this has been answered, is this once again a thread resurrection?

your argument is simply not possible. the reason is, that although protein folding is an optimization process and you could replicate this measure of difficulty in a way of finding a solution that is at least of some certain quality, it still won't do the necessary trick. this kind of optimization has an unknown optimal value and the amount of work is in no way predictable. the reason why it is unpredictable is based on the fact, that you optimize real-world data which is not homogeneous and contains additional information (in an abstract sense). this means, this is a calculation based on processing data and extracting information (the structure). the sha256 hashing done for the blockchain is homogeneous and does not incorporate any additional information. therefore it's progress and outcome (after trying hashes) can be predicted even before the procedure has even started.

also, imagine the inverse: you somehow (by physical experiment) already know the solution to a protein folding problem and now you get it as your workload. this would make you the immediate winner and you get the block reward. hence, the pre knowledge saved you cpu power and that's not desirable in any way.

thus, securing the blockchain (in the way bitcoin does) must not depend on any higher information, just raw data plus a "useless" computation.

We can scale the difficulty of the SHA-256 problem over a huge range, with constant effort required to verify the results.  I don't think that protein folding has this property.  Actually, I don't think that any "useful" work has that property.

I'm sorry dude, I think you are confused about the properties of either SHA-256, protein folding, or both.  I've read a ton of threads on these forums started by people that wish that we could use a different algorithm, and so far not a single person, including you, has shown an algorithm that has the properties that we need.

Just a quick recap:

1.  The output must be provably linked to the input, and the input must contain proof of the block (the Merkle root).
2.  The output must not be guessable by any means other than doing the attempt.
3.  The chance of success must be scalable over a huge range (probably at least 128 bits, bare minimum, and that might even be pushing it).
4.  The output must be easily verifiable.

Protein folding seems to satisfy condition 2, and maybe condition 4.  But conditions 1 and 3 conspire against all of these efforts.

Good luck man.  I think you are wasting your time, but I wouldn't mind being shown that I'm wrong about this one.

I would encode the hash using a list of molecules.

Given a list of molecules, and assuming there is a standard way of serializing their chemical formula in a unique, unambiguous manner, this list has a unique basic order A, B, C, D, ...
If this list is at least 58 long, then it is possible to encode any number from 0 to 2^160 using a permutation of A, B, C, ..., for instance F, G, T, Z, A, C....  This is due to the fact that 58! > 2^160.
So the miner must find solutions in a decreasing difficulty order.  This means that he must first work on F, then he must find a better solution for G, then an even better solution for T, and so on.
Then a block is not considered valid unless its hash encodes into a permutation of the molecules in their decreasing difficulty order.

The way the miners would solve the problem does not matter much.  It's a bit like some people with bitcoin found better technical solution to compute hashes, either software or hardware.

I told you, you can make a correspondence between hashes (there are 2^160 of them) and permutations of 1, 2, ..., 58 (there are 58! of them).  See https://en.wikipedia.org/wiki/Permutation#Numbering_permutations

For a molecule, the performed difficulty is the logarithm of the ratio between previous action and new action.
You make a list of given molecules in their decreasing performed difficulty order.  It has to correspond to the corresponding hash value (given correspondence mentioned above).

Yes.


Yes.


Not exactly the sum of changes, but otherwise yes that's the overall difficulty.

If the action for block n and molecule M_i is A(n, M_i), then the difficulty D_{n,i} is

D_{n,i} = ln( A(n-1, M_i)/A(n, M_i) )

And the global difficulty D_n is the sum for all i.


Well, the permutation is defined by the hash, and you use it to search paths so that D_{n,i} is decreasing with i.


Yes it can.  The miner just has to work very little on the molecules "to the left" and harder with molecules "to the right".  He can just set his requirements to match those of the previously computed path in the list.

The hash defines a permutation of the molecules.  For the block to be valid, this permutation must match the one defined by the decreasing difficulty order.