Ethereum: What complexity class is Bitcoin’s proof-of-work (Hashcash) in?

To address this question accurately, I will define an idealized hypothetical «perfect» hash function H(n), which has good scalability properties. Then, I will formulate a PERFECT HASHCASH problem in terms of the time complexity class P(n). This will help us understand whether Bitcoin’s proof-of-work (hashcash) is NP-complete or not.

The Problem: Perfect Hash Function

A perfect hash function H(n) would be an algorithm that takes a large input n and produces a fixed-size output, usually represented as a number. In the context of cryptographic applications such as digital signatures and nonces, a well-designed hash function can provide strong security against various types of attacks.

Hashcash is an example of a proof-of-work-based hash function. It is designed to validate transactions on the Bitcoin network, ensuring that they are valid and cannot be spent twice. Here’s how it works:

• A miner (a node on the Bitcoin network) generates a unique identifier for each transaction.

• The miner calculates a hash value for the transaction using a combination of its contents and the block number.

• The resulting hash value is compared to a target value, which can be set by the sender of the transaction.

If the two hashes match, it means that the transaction was successfully validated (i.e., «found» in the database). In this case, the miner is rewarded with newly minted Bitcoin coins.

The PERFECT HASHCASH problem

Now, let’s define a PERFECT HASHCASH problem that we can use to evaluate the computational complexity of hashcash:

Problem: Given an input n, find all possible outputs x such that H(n) = x modulo 2^64.

In other words, given a large number n, we need to generate all possible values ​​of x in the range [0, 2^64] using the hash function H(n). The key idea here is that h(n) can be represented as:

h(n) ≡ x (modulo 2^64)

where h(n) is the hash value for input n.

Time Complexity Analysis

To analyze the time complexity of PERFECT HASHCASH, we can use the following steps:

• Compute the hash value H(n) using the provided inputs and a cryptographic hash function (e.g. SHA-256).

• Find all possible outputs x in the range [0, 2^64] that satisfy the equation h(n) = x modulo 2^64.

• Count the number of valid solutions.

The time complexity of PERFECT HASHCASH can be analyzed by considering the number of possible inputs n and the number of iterations required to find a solution for each input.

Computational complexity class

Using the number of possible inputs n, we can estimate the computational complexity of PERFECT HASHCASH. In general, the time complexity of hash functions is classified into two main classes: P(n) and NP(n).

• P(n) problems are those that can be solved in polynomial time by a deterministic algorithm that runs in O(n^d) time (where d is the depth of the problem), where n is the input size.

• NP(n) problems are those that can be verified in polynomial time using a witness (e.g. a solution to the problem). If a solution exists, it must also be verifiable.

In this case, since PERFECT HASHCASH involves finding all possible outputs x for a given input n, we can estimate its computational complexity as follows:

• If n is relatively small (e.g. <10^8), then PERFECT HASHCASH may take O(2^n) time.

• For larger inputs, the number of iterations required to find a solution grows polynomially with the size of the input.

Conclusion

In conclusion, while we have not explicitly shown that hashcash is NP-complete or not, our analysis suggests that it may be in P(n). However, this remains an open problem and requires further research.