In P2P systems, like Holochain, and presumably many other P2P systems, there's often an assumption that peers will check the validity of the claims of other peers and report them to the rest of the network if they're cheating, but this assumption often isn't supported by the incentives of the protocol.

If the assumption that people are actively doing validation is true, then there is no incentive to lie to the network, because the peer who lies will be detected, punished and ignored. But if that's true, then there will be no lies to detect, and then there is no incentive to check for them.

It's an unstable equilibrium. When participants start to exploit this fact, first by ceasing to check (which lets them make cheaper validator bids, which gives them a competitive advantage), and then by exploiting that and introducing corrupted state to the network, we can name this syndrome "Habituation".

I don't think it's happened yet, but this is likely due to features of today's computing landscape that will likely go away eventually, a combination of low specialization/validator competition (and so, a low degree of optimization for cost), rigid source code management systems (so people just run the default client), and small scales (so the incentive to attack the system is too weak).

Resolves

• Yes, when someone finds an instance of Habituation occurring

• No, when I am convinced that a robust p2p verifiable computing protocol exists that has solved the habituation problem for most distributed computing usecases. The protocol must not require Special Computers (described below)

There are two approaches that I think work today, but they require Special Computers.

• Trusted Execution Environments can provide a pretty firm guarantee that they're running a specific piece of code (so, validating), and though it may be possible to hack a TEE, it could be made expensive enough that we can guarantee that a high enough percentage of the network are verifying. There's nothing inherently wrong with the TEE solution, but for some reason intel's branded TEE, SGX, doesn't seem to be enabed by default on most peoples' computers, and I've heard nothing about TEEs being subject to any international audits, so I'm not sure how much we should trust their security. If there's a software zero day, they're kind of trash. It's probable that they'll always be hackable through hardware.

• Zero Knowledge computers like Risc0 can produce a succinct proof that specific code was run all the way back to the geneses event. Unfortunately, it is currently like 10,000 times slower than regular code. Of course, if you just replicated a conventional computation among just 1000 peers, that would already give you a firm enough assurance that the computation has been correctly validated by at least one of them, so it's not clear Risc0 is really giving us much.

So for the time being, we'd like to find a way of doing it without Special Computers.

For now, it seems as if these incentives are not easy for p2p systems to fully banish. If you think you have a protocol that banishes them, feel free to lay it out in the comments, but I may already be able to tell you how the incentives break.