The Sleepy Model is a consensus protocol model that was designed to handle dynamic participation, where validators (or nodes) can join and leave the network at any time. This is in contrast to traditional consensus models, which assume a fixed set of validators. In the Sleepy Model, validators can be "awake" (participating in the protocol) or "asleep" (not participating). An adversary can choose which validators are awake and which are asleep, but there are some restrictions to prevent the adversary from completely controlling the network. For example, the adversary can't wake up validators that it previously put to sleep, and it can't put validators to sleep that it previously woke up. The Sleepy Model is designed to be secure as long as more than half of the validators are honest and awake. It guarantees safety (nothing bad happens) and liveness (something good eventually happens) under these conditions. Original model assumes the number of active honest nodes can fluctuate dynamically at the adversary's control, but all faulty nodes are always awake. **Sleepy Model with Fluctuating Adversary**, as outlined in [[Byzantine Consensus under Fully Fluctuating Participation]], extends to allow the number of faulty nodes to fluctuate as well. **Sleepy Model with Growing Adversary:** Faulty nodes not allowed to go from active to inactive. Required under PKI settings in aforementioned paper ### Generalized Sleepy Model The Generalized Sleepy Model, used by [[RLMD-GHOST]] is an extension of the Sleepy Model that introduces the concept of "τ-sleepiness". In this model, an execution is considered τ-compliant if it satisfies τ-sleepiness, which involves the number of active validators at a certain round being greater than the number of adversarial validators at the next round, along with the number of validators that were active at some point between two previous rounds but not at the last round. This model is designed to handle more complex scenarios where validators can be active or inactive at different times, and where the adversary has more control over the network. It provides a more realistic model for real-world blockchain networks, where validators can join and leave the network at any time and where network conditions can vary. For some fixed parameter $1 <= \tau <= \infty$ , the following condition holds for any slot *t* after GST: **$\tau$-sleepiness at slot t**: $|H_{t-1}| > \left|A_t \cup \left(H_{t-\tau,t-2} \setminus H_{t-1}\right)\right|$ $H_{t},A_{t}$ are the set of active validators and adversaries at round $4\Delta + \Delta$ $H_{s,t}$ is the set of validators that are awake during any slot from s to t $\tau$=1 corresponds to [[Goldfish]], and constrains the adversary in the minimum way that can allow for a secure protocol under dynamic participation The number of validators that can go offline or be put to sleep is AT MOST equal to the number of adversarial validators. When $\tau=\infty$ all honest validators which are not active at (t-1), and which have voted at least once in the past, are counted together with the adversarial ones. - If all validators have voted at least once in slots \[0,s-1], the number of active honest validators in a round must be greater than half of all validators for all slots t>s. Dynamic participation only allowed in an extremely narrow sense. - This is because all sleeping or offline validators can't contribute to operation, so they increase the relative power of the adversarial validators - If fewer than half of validators are active, the combined number of adversarial validators and inactive honest validators could be greater than the number of active honest, violating the condition. - Effectively limits dynamic participation to situations where more than half of all validators are active. The number of validators that were active at some point between two slots but not at the last slot must be less than or equal to $\tau$ times the number of adversarial validators in the current slot ### Partially Synchronous Sleepy Model Presented in [[Ebb-and-flow protocols: A resolution of the availability-finality dilemma]] In a partially synchronous system, there's a known upper bound on message delay but it's not known for message participants After global stabilization time has passed, the system begins making assumptions about message delivery, particularly that every message sent is received within some fixed amount of time. Every message sent by an awake validator is received by all other awake validators within some fixed amount of time Provides a more realistic model for blockchain networks