Find a legal sequential explanation
Linearizability is a correctness condition for concurrent objects. Each completed operation must be explainable as taking effect at one instant between its invocation and response. The resulting sequential history must satisfy the object's sequential specification and preserve real-time precedence: an operation that returns before another begins must appear first. The implementation itself need not execute sequentially. Several operations can overlap internally as long as their externally observed results admit an explanation meeting these conditions. This makes the property a statement about allowed histories rather than a particular locking technique.
Overlapping and nonoverlapping operations
For a register initially holding zero, suppose write(1) finishes before a read is invoked and no other write occurs. Returning zero would violate the required real-time order and the register specification. If the read overlaps the write, however, an explanation that places the read first can be legal. Overlap grants ordering freedom, not permission for arbitrary results. Recording invocation, response, and result values makes this distinction visible. A trace containing only completion timestamps can omit information needed to determine which operations actually overlapped.
Reasoning about a linearization point
A protected state update inside a critical section can sometimes serve as a linearization point. In a compare-and-swap algorithm, a successful CAS can be a candidate. Neither rule is automatic: unsuccessful operations and returned values also need to match a legal object history, and some algorithms require more subtle reasoning about when an operation takes effect. A useful proof states the sequential specification first, identifies candidate effects, and checks all relevant interactions. Choosing an attractive machine instruction without this reasoning is not a correctness proof.
What the property does not promise
Linearizability does not promise fast execution, bounded completion time, or persistence after a crash. It also does not turn an arbitrary application sequence spanning several objects into one atomic transaction. Individual object guarantees and the invariant of the larger procedure must be considered at their respective boundaries. Durability, availability, and progress properties need separate specifications. When comparing implementations or distributed placements, name which guarantee the application requires; a system can be correct by this condition while still being unsuitable because its latency or failure behavior does not meet the workload needs.