Combine a physical component with a causal tie-break

Represent a hybrid timestamp as a pair (l, c). The first field is a physical-clock-like value; the second counts causal ordering steps when the first field does not advance. Compare pairs lexicographically: compare l first, and compare c only when l matches. Do not add the fields as if both were milliseconds. An implementation might pack them into one integer, but packing is a representation choice requiring enough range for both components. The logical component provides ordering information within a repeated physical value, not a calibrated fractional interval between those events.

For a local or send event, choose the new physical-like component as the maximum of its previous value and the current physical reading. If that choice equals the previous component, increment the logical counter; if physical time has moved strictly ahead, reset the counter to zero. Consequently a backward physical adjustment does not force the hybrid tuple backward. The tuple can continue advancing logically while the physical reading catches up. This is an ordering property, not evidence that the physical clock reading was correct or that an event occurred at the first field's apparent calendar instant.

On receiving a message, first choose the maximum of the previous local l, the message's l, and the current physical reading. Then choose the counter according to which maximum supplied the value. When both old local and remote l equal the chosen value, increment the maximum of their counters. If only the old local component matches, increment its counter; if only the remote component matches, increment the remote counter. If a strictly newer physical reading wins over both, use zero. Keeping these cases explicit avoids losing a message dependency at equal physical components.

Correct updates ensure that happened-before implies a strictly increasing hybrid tuple. The converse still fails, just as it does for scalar Lamport clocks: two independent events can have different physical-like components without any causal relationship. Equal tuples are possible for concurrent events, so an application needing unique identifiers must add a separately justified uniqueness mechanism. Hybrid clocks also do not encode the full participant-indexed history of vector clocks. Choose them for the ordering and approximate-time properties a protocol actually needs, rather than assuming a compact timestamp can answer every concurrency or conflict question.

A hybrid timestamp can inherit an advanced physical component from a remote host. Bounding how far it differs from local physical time therefore requires synchronization assumptions about the participating clocks and valid inputs. An algorithm cannot promise arbitrary physical accuracy when those assumptions disappear. Operational implementations need a policy for excessive forward readings, restart state, counter exhaustion, and upgrades that change encoding. Silently wrapping a finite logical field to zero at unchanged l violates strict local order. Blindly accepting a far-future component can also leave later timestamps ahead of physical time for an unexpectedly long interval.

Use the modular instrument to inspect only the exhaustion hazard. Reset, set both modulus m=4 and additive step a=1, predict what follows residue three, then Play or Step. The orbit returns to zero at its fourth addition; a fresh comparison requires Reset and re-setting both controls. A real hybrid clock cannot treat that wrapped field as an ordinary increasing counter at the same l. This instrument implements modular addition, not physical readings, receive cases, or a hybrid-clock overflow policy. Use its clear failure of monotonic numerical order to motivate testing the representation alongside the abstract update rules.