Concurrency is not performance. Concurrency is authority overlapping in time.

When two actions happen “at once,” law must decide which one is valid.

I. The Myth of Technical Concurrency

Engineering frames concurrency as:

threads

locks

async execution

throughput optimization

This is incomplete.

Concurrency decides:

who acted first

whose action prevails

whether outcomes are compatible

whether conflict is allowed

That is law.

II. Overlapping Authority Requires Arbitration

If two actors modify the same state:

one must be first

one must be rejected

or both must be merged under declared rules

Undeclared arbitration is hidden governance.

Hidden governance is illegitimate.

III. Locks Are Not Law

Locks prevent corruption. They do not justify outcomes.

A lock can:

delay one actor

block another

serialize execution

But it cannot answer:

who had the right

which intent was valid

why one action won

Locks enforce order, not legitimacy.

IV. Optimistic Concurrency Is Legal Choice

Optimistic concurrency says:

“you may try”

“if state changed, you lose”

That is a rule.

Rules must be:

explicit

declared

recorded

replayable

Undocumented version checks are silent policy.

V. Concurrency Without Recording Destroys Truth

If concurrent attempts are not recorded:

losing attempts disappear

conflicts are erased

intent is lost

The system reports a clean history that never existed.

That is false history.

VI. Time and Concurrency Are Linked

Concurrency without time:

cannot be ordered

cannot be audited

cannot be replayed

Every concurrent decision requires a temporal boundary:

timestamp

version

causal order

Without time, authority is undefined.

VII. Replay Must Reproduce Concurrency

Replay must show:

the same overlaps

the same conflicts

the same rejections

the same winners

If replay serializes what was concurrent, audit fails.

VIII. Infrastructure Cannot Decide Concurrency Law

Concurrency rules must not live in:

database defaults

ORM behavior

framework internals

message broker semantics

Those are execution tools.

Law must live in:

kernel

policy

versioned rules

IX. Final Conclusion

Concurrency is a legal problem.

A lawful system:

treats concurrent actions as competing authority

declares arbitration rules explicitly

records all attempts, including failures

replays concurrency deterministically

Anything else allows systems to resolve conflict by accident rather than by rule.

Concurrency Is a Legal Problem