From Wikipedia:
The PoW requires miners to find a number called a nonce (a number used just once), such that when the block content is hashed along with the nonce, the result is numerically smaller than the network's difficulty target.
The fact that a miner found such a nonce does not guarantee that it will become part of the consensus blockchain though. What percentage of them fail to join the consensus blockchain?
The term for this is "orphan rate" or "fork rate", as each created block which doesn't make it into the eventually accepted chain is effectively a tiny chain fork that doesn't get extended. Such blocks are sometimes called orphan blocks (though that term is a misnomer).
These forks occur when two blocks are found nearly simultaneously, where the later miner was still working on the previous block. The better the latency between miners, the shorter the time between the blocks needs to be for this to occur.
It is very hard to get exact statistics on this, for the simple reason that nodes in the network do not relay blocks which aren't considered part of the main chain. If a node receives a block at height H, and then another one at the same height H, the latter will not be considered part of the main chain unless it is extended first. Thus, generally such a fork will involve a condition where one part of the network hears about one block first, and another part of the network that hears about the other one first. Nodes on the boundary between the two will generally hear about both immediately. Nodes that heard the losing block first will eventually hear about both. Nodes that heard about the winning block first - generally the largest subset - will typically not ever hear about the losing block.
Thus, the best we can do is gather statistics from forks that well-connected nodes saw, though even that will be necessarily an underestimate: the "worst" forks don't propagate at all, not even past the mining pool that created them, and thus will not show up in anyone's statistics.
On my own rather well-connected node, I've seen 13 forks in the past 4 months (since block 800000). The https://fork.observer website lists forks they see on their nodes, which currently shows a similar number over that timespan. I believe https://blockchain.info used to list forks somewhere in the past, but I can't find that anymore.
If we use that number as a lower bound, the answer to your question would be at least 0.07%. The number can change wildly over longer time periods though, as it depends on the composition of blocks, the geographic distribution of miners, their connectivity, and the technologies used to connect them (e.g. BIP152 compact blocks helped reduce latency between miners, and the public FIBRE network while it was still operational helped more).
The fact that a miner found such a nonce does not guarantee that it will become part of the consensus blockchain though.
this is true because there might be multiple miners who find the correct nonce at the same time. the one who quickly propagates wins.
there is a term called orphan block:
Orphan block is a term used by the general public, but in technical documents it is described as a stale block. An Orphan block is created when two miners (or more) find the solution at the same time.
Since each miner will broadcast the solution to the network and the network requires a couple of moments to synchronize, there will be two blockchains for a brief period of time. Each part of the blockchain will think that their solution was found first and is the solution that should be used primarily. In reality, both solutions are valid.
Once the new blockchain is active, the “race” between both chains begins. Whichever chain will have the longer chain will be the main chain.
You should say Bitcoin, not just blockchain: Bitcoin is the basic reference model for all blockchains, but there may be protocol variations with other blockchains.
The fact that a miner found such a nonce does not guarantee that it will become part of the consensus blockchain though. What percentage of them fail to join the consensus blockchain?
The short answer is a vanishingly small percentage, i.e. almost zero, but not for the reasons you seem to imply. Here is schematically how it goes:
a Bitcoin miner is associated (talks) to a Bitcoin node: it's the node that keeps track of the blockchain as well as, among other things, of the list of pending transaction (that it knows about at any moment: typically wallets and exchanges submit transactions to a node, to be then replicated to the entire network);
based on the list of pending transaction, a job is submitted to the miner in order to search for a new block;
At this point one of two things can happen:
the node receives a new block before the miner is done: in this case the miner's job is aborted and, possibly, a new job gets started with the updated list of pending transactions; otherwise:
the miner finds a block before any new block has arrived to the node: in this case the miner submits the block to the node, and at this point the block is part of the blockchain, which just means it has been accepted by the immediate node and will be progressively propagated to the rest of the network.
Propagation entails latency: time is needed for a new block to reach all nodes of the network. Hence, when two miners find a new block almost at the same time, they both transmit it to their nodes, which accept the block since they don't yet know another block was created somewhere else. In that case what is happening is called a "network fork": these are quite frequent but usually resolve themselves in a matter of minutes, rarely more, by the rule that the longest chain wins. (I am not getting into too many details for simplicity: more technical details can be found online.)
So, now back to your initial question: there is one and only one possibility for a valid block to literally not make it to the blockchain, and that is if the miner finds the block almost exactly at the same time the node receives a new block, in which case the miner might indeed try to submit its block to the node and the node would have to refuse the request. And this is the event that I am dubbing vanishingly probable: based on my competence and experience, I am not aware of public statistics about this.
Incidentally, nonces are not the only element in a block that a miner can play with in order to vary the block content and get different hashes, indeed nonces are uint32 numbers, so there would not be nearly enough. There is also the timestamp, as well as the coinbase attribute of the so called generation transaction, i.e. the one in which miners rewards themselves: plus a miner decides which of the pending transactions to actually include in the block and in which order.
Imagine that all of the Bitcoin network's hashing is being done on a single giant imaginary computer, that doesn't stop if it finds a successful block.
We can perform a calculation of the probability that it finds two valid blocks in one second using public estimates of the hashrate as well as the known target.
two_valid_blocks_in_1sec_probability ~= 100% * (hash_rate_per_sec * target / 2**256 ) ^ 2
Now imagine that the hash rate is distributed across the network of miners. Whether a valid block fails is dependent on the time it takes a valid block to reach, and be accepted by, rival miners. As an estimate, we can use the time it takes a block to reach nodes covering half of network hashrate; the block propagation time. Adjusting the above formula, it becomes:
valid_block_failure_probability ~= 100% * (hash_rate_per_sec * mean_block_propagation_time * target / 2**256 ) ^ 2
Note this assumes terms for ^3, ^4, ^5 ... (which, strictly, should be added on) are not significant. This also assumes that the time it takes nodes to validate and accept valid headers is << the mean propagation time.
Here's a python script to do that:
# Block 809295
hash_rate_per_sec = 405000000.0 * 10**12
# approximated from https://www.blockchain.com/explorer/charts/hash-rate
target = 0x00000000000000000004ed7f0000000000000000000000000000000000000000
# from https://learnmeabitcoin.com/technical/target
period_secs = 0.5
# from https://bitcoin.stackexchange.com/a/114196/34190
# mean block propagation time (a block will reach nodes responsible for half of network hashrate in this time).
prob_per_period = hash_rate_per_sec * period_secs * target / 2**256
N = 2
prob_N_hashes_in_period = prob_per_period**N
print('The probability that the bitcoin network will produce',N,'valid blocks in', period_secs, 'seconds is ', prob_N_hashes_in_period, ' Based on hashrate and target at block 809295.')
Which gives the following printout:
The probability that the bitcoin network will produce 2 valid blocks in 0.5 seconds is 6.81306666296744e-07 Based on hashrate and target at block 809295.
Using this, in answer to your question, we can say that, if the mean block propagation time is 0.5s, at block height 809295:
If a miner has found a successful block, there is a 0.00007% (1 sig fig) chance that it will not reach the consensus Bitcoin blockchain
The probability is sensitive to the estimated propagation delay:
mean_block_propagation_time [s] |
valid_block_failure_probability [%, 1 sig fig] |
|---|---|
| 0.5 | 0.00007 |
| 1 | 0.0003 |
| 1.5 | 0.0006 |
| 2 | 0.001 |
| 2.5 | 0.002 |
| 5 | 0.007 |
| 10 | 0.03 |
| 20 | 0.1 |
The idea of collusion amongst miners (tacit or overt gatekeeping) slowing acceptance was not considered.