Consensus Does Not Create Truth Agreement and Observation in Distributed Systems

Abstract

A distributed system comprises spatially separated processes communicating via message exchange where transmission delay is significant relative to local events. Individual observation is restricted to a partial ordering because processes remain unaware of concurrent actions until receiving messages or reassembled network packets. Agreement protocols resolve these informational gaps by using logical clocks to extend the “happened-before” relation into a consistent total ordering. Consensus layers then identify a single canonical path through a tree of potential blocks to establish a definitive, authoritative history.

Definitions

• Distributed System: A collection of distinct, spatially separated processes that communicate by exchanging messages.

• Packet: A small segment of a larger message divided for independent processing and transmission over computer networks.

• Happened-before Relation (→): An irreflexive partial ordering on the set of all events in a system based on local sequences and message exchanges.

• Logical Clock: An abstract mechanism for assigning numbers to events to represent the order of occurrence without reference to physical time.

• State Machine: A set of possible states and commands where a transition function executes commands to morph one state into another.

• Fork: A disagreement between nodes regarding which root-to-leaf path in a block tree is the canonical blockchain.

System Model

Each process consists of a sequence of events, where sending or receiving a message constitutes an event. A system is defined as distributed if message transmission delay is not negligible compared to the time between events within a single process.

Networking within these systems utilizes packet switching, where equipment processes packets independently. Packets may take different network paths to the same destination and are reassembled upon arrival using header information.

Ethereum operates as a transactional singleton machine with shared state. The system begins at a genesis state and incrementally executes transactions to morph into a current state. The architecture is divided into an execution layer, which defines the rules for updating the virtual machine state, and a consensus layer, which defines the rules for determining the canonical history.

Observation and Visibility

Distributed systems lack a single, objective chronological order because the “happened-before” relation defines only a partial ordering. It is frequently impossible to determine which of two events occurred first if they lack a causal link.

Two events are concurrent if neither can causally affect the other. A process remains ignorant of concurrent actions in another process until it receives a message, meaning no node possesses a global view of events as they occur in physical time.

Observation is further fragmented by network protocols that divide data into independent segments. A destination computer only reassembles the original message after receiving and ordering all individual packets. System visibility is therefore constrained to events observable within the system’s causal framework rather than absolute physical time.

Agreement and Canonical History

Consensus algorithms extend the “happened-before” partial ordering into a consistent total ordering of all events. This total ordering enables a distributed system to resolve conflicts and synchronize states despite fragmented observations.

Ethereum establishes agreement by selecting one official path through a tree of possible blocks to prevent the coexistence of incompatible states. This process is managed by the consensus layer using the LMD GHOST (Latest Message Driven Greedy Heaviest-Observed Sub-Tree) rule to nominate the head of the chain.

State transitions are deterministic. Once transactions are executed in the canonical order via the state transition function, the resulting state change is mathematically certain. Agreement therefore provides an incorruptibility of judgment derived from a disinterested algorithmic interpreter operating solely on the transaction log and predefined rules.

Limits of Consensus

Anomalous behavior occurs when a system’s total ordering contradicts the order perceived by users. This arises when external causal links, such as communication outside the system, are not observable through internal message exchange.

Failure ambiguity exists because there is no inherent way to distinguish a crashed process from one that is merely pausing between events without reference to physical time.

The Oracle Problem reflects the fact that internal agreement protocols cannot guarantee the accuracy or timeliness of information originating outside the system. Finally, true randomness cannot be produced within a deterministic system. Consensus can only approximate pseudo-randomness using internal data, such as recent block hashes.

Core Finding

No single global observation exists in a distributed system. Consensus establishes agreement on a canonical history, but it does not create shared knowledge or a universal view of events.