---
slug: uncontrolled_concurrent_ordering_outcome
name: Uncontrolled Concurrent Ordering Outcome
one_liner: "When multiple actors act concurrently on shared state without a sequencing rule, the result is fixed by the uncontrolled relative order in which their effects land rather than by the actors' individual choices."
type: prime
schema_version: 2
status: density_v2_draft
categories: [structural, computational, social]
origin_domain: concurrent_computing
alternate_origin_domains: [distributed_systems, economics, evolutionary_biology, collaborative_editing]
aliases: [order_dependent_outcome, timing_determined_result, unsequenced_contention, nondeterministic_interleaving, first_to_land_wins]
related: []
solution_archetypes: []
review_flags:
- "OPERATOR-DERIVED (op-05 generalization) — the proposed GENUS of `race_condition` (lift: strip the computing/shared-memory frame — threads, memory writes, atomicity — to expose the bare pattern of an outcome determined by uncontrolled relative ordering among concurrent actors). Discovered in the op-05 remaining-strata sweep 2026-07-03. Tier B candidate (COINAGE RISK — see keep/cut). STATUS: HOLD pending owner keep/cut."
- "Tier-B domain-instance / coinage flag (from data): distinct from the coordination/asymmetry family; siblings span auctions (simultaneous bids, no tiebreak), collaborative editing (two editors overwriting one document), and evolution (simultaneous mutations competing for one niche). Sibling-test passes, but the genus label is a proposer coinage, not an established cross-field term — treat with skepticism."
- "Created 2026-07-03; STUB ONLY (frontmatter + Core Idea + Notes). SI/SF/similarity are PROPOSER ESTIMATES pending triangulation. Body sections (Structural Signature onward) NOT written."
- "Phase-C action: re-similarity-check vs `race_condition` (the input) and the named siblings, AND vs any existing coordination / concurrency / priority / contention / first-mover prime; confirm it is a genuine genus (covers the input AND the auction/editor/evolution siblings) and not a domain instance, a restatement of the input, or an alias of an existing coordination prime; draw a subsumption edge input→candidate + sibling edges at incorporation; sync one_liner to a v1 draft per CLAUDE.md before merge."
substrate_independence:
  composite_substrate_independence: 4
  domain_breadth: 4
  structural_abstraction: 4
  transfer_evidence: 3
  reasoning: 'The bare structure — two or more actors act on shared state without a sequencing guarantee, so the outcome is fixed by the uncontrolled relative order in which their effects land rather than by the content of their actions — is genuinely domain-neutral and recurs across computing, markets, collaborative work, and biology. That supports domain breadth and structural abstraction around 4. It is not a 5 because the pattern presupposes a shared mutable resource and concurrent access, a fairly specific setup, and because its boundary against the broader coordination/contention family is not yet crisp. Transfer evidence is real (the siblings are unlike) but the genus label is a proposer coinage rather than an established term, so transfer_evidence sits at 3 pending confirmation the siblings are not better filed under an existing coordination or concurrency prime.'
similarity_to_nearest_existing_prime:
  slug: race_condition
  similarity: 0.64
structural_framed:
  label: structural
  aggregate: 0.16
  criteria: {vocab_travels: 0.2, evaluative_weight: 0.1, institutional_origin: 0.1, human_practice_bound: 0.2, import_vs_recognize: 0.2}
  rationale: 'The pattern is essentially structural: it describes a relation among concurrent actors and shared state with no evaluative content (an order-determined outcome is neither good nor bad in itself) and no binding to a human institution. Its vocabulary (concurrent actors, shared state, ordering, no sequencing rule) travels across computing, markets, editing, and biology. The mild nonzeros reflect the computing-origin flavor of the framing rather than any real domain-boundness. Reads structural, with a coinage caveat lowering confidence rather than the label.'
phase_b_passes_completed: []
---
# Uncontrolled Concurrent Ordering Outcome

## Core Idea

Uncontrolled concurrent ordering outcome is the structural pattern in which *the result of a system is fixed by the uncontrolled relative order in which concurrent actors' effects land on shared state, rather than by the content of the actors' individual choices*. The single constraint stripped from the input `race_condition` is its computing frame: the input describes threads, memory writes, and the absence of atomicity guarantees on shared memory. This genus keeps the load-bearing skeleton — concurrent actors, a shared target, no sequencing rule, order-determined result — and drops the requirement that the actors be threads or the shared state be memory. What remains is any setting where several actors touch the same thing at the same time without a rule to sequence them, so *when* effects land, not *what* the actors decided, decides the outcome.

The load-bearing anatomy has three parts. First, *concurrent actors on shared state*: two or more agents operate on the same target within an overlapping window. Second, *absent sequencing guarantee*: there is no rule, lock, or protocol that fixes the order in which their effects apply. Third, *order-determined outcome*: because sequencing is uncontrolled, the final state is a function of the (effectively arbitrary) interleaving of effects — often literally "whichever landed last wins." The characteristic payoff, when the pattern is *recognized*, is diagnostic and prescriptive: it names precisely why a system is nondeterministic and points at the fix — impose sequencing (locks, tiebreak rules, versioning, priority). The characteristic cost and failure, when the pattern is *unmanaged*, is a nondeterministic, hard-to-reproduce, order-sensitive result: identical actor choices yield different outcomes on different runs, lost updates occur silently, and the system's behavior depends on timing no one controls. The recurring insight is that the cure is never to change what the actors decide but to control the *ordering* — supply the missing sequencing rule.

Read as a genus rather than as a shared-memory bug, the same skeleton recurs across structurally unlike domains. In *markets*, auction bids arriving simultaneously with no tiebreak rule leave the allocation determined by arrival order rather than by bid content — the same order-determines-outcome shape, resolved by imposing a tiebreak or a strict timestamp. In *collaborative editing*, two editors overwriting the same shared document without merge or versioning produce a final text fixed by who saved last, not by either editor's intent — the lost-update failure, resolved by version control or operational transforms. In *evolutionary biology*, simultaneous mutations competing for the same ecological niche can have their fixation decided by the accident of relative timing and drift rather than by fitness alone. Shared-memory race, simultaneous auction bids, concurrent document overwrite, and competing niche-mutations are four genuinely different substrates; the shared skeleton — concurrent actors, no sequencing, order-determined result — is the candidate lift.

## Notes

**Provenance.** Produced by operator 05 (generalization / lift) as the proposed GENUS of the input `race_condition`, by stripping the computing/shared-memory frame to expose the underlying pattern of an outcome determined by uncontrolled relative ordering among concurrent actors. Surfaced in the op-05 *remaining-strata* sweep on 2026-07-03. It claimed three cross-domain siblings — simultaneous auction bids with no tiebreak, two editors overwriting one document, and simultaneous evolutionary mutations competing for one niche. Manifest tier: B (Tier-B "rest").

**For owner evaluation (keep/cut).** Candid Tier-B assessment: this is a **proposer COINAGE** — "uncontrolled concurrent ordering outcome" is a descriptive label the sweep minted, not an established cross-field term. Treat it skeptically. The case FOR: the order-determines-outcome shape is real, the manifest explicitly flags it as *distinct from the coordination/asymmetry family* (a useful negative claim, meaning the sweep already checked it against the nearest corpus neighborhood), and the three siblings are genuinely unlike substrates that pass the sibling-test. The specific RISKS, in priority order: (1) **alias of an existing coordination / concurrency prime** — the sharp keep/cut question. Even though the data claims distinctness from coordination/asymmetry, Kurt should confirm the corpus has no existing concurrency, contention, priority-ordering, or first-mover prime this collapses into; a race-condition-shaped structure is close to the coordination family and the boundary must be drawn deliberately. (2) **restatement of the input** — similarity to `race_condition` is ~0.64; decide whether this is a genus worth minting or whether `race_condition` should be re-headed structurally with the auction/editing/evolution cases as examples. (3) **too thin / near-tautology** — "outcome depends on timing when there's no sequencing rule" risks being definitionally true of any unsequenced concurrent process; the keep decision should confirm the *shared mutable state* + *effects-land-in-some-order* pairing carries enough content to be load-bearing. **Sharp question for Kurt:** is this a genus distinct from the corpus's coordination/concurrency primes, or the same structure the sweep failed to match on — and if genuinely new, is it worth a prime or better handled as an example under an existing coordination prime?

**At incorporation.** Re-run similarity against `race_condition` (the input) and — critically — against any existing coordination, concurrency, contention, priority/ordering, or first-mover prime to rule out an alias before accepting; this is the deciding check for a Tier-B coinage flagged as "distinct from the coordination family" (verify that claim). If distinct, draw a subsumption edge `race_condition` → `uncontrolled_concurrent_ordering_outcome` and sibling/example edges to the auction, editing, and evolution cases. Write a v1 draft and sync the one_liner across v1 and v2 per CLAUDE.md before merge.
