Concurrency Tax from System Structure: A Graph Theory of Processing Overhead

A function that takes 4 milliseconds in a benchmark takes 23 milliseconds in production. A surgeon who ties a knot in 8 seconds in the simulation lab takes 14 seconds in the operating room. A developer who fixes a bug in 20 minutes when working alone takes 55 minutes during a regular workday with messages, meetings, code reviews, and context switches. A single-threaded program that completes in 100 milliseconds takes 340 milliseconds when running alongside three other processes on the same machine. Nothing is wrong with the processor in any of these cases. The function is the same function. The knot is the same knot. The bug is the same bug. The program is the same program. The processor's capability has not degraded. What changed is the environment — other activities are competing for shared resources. The work itself is identical. The overhead is the difference, and the overhead is large. This overhead has names in every domain. In computing it is called contention. In organizations it is called coordination cost. In cognitive science it is called task-switching cost. In manufacturing it is called changeover time. Each domain has its own vocabulary and its own local models for why things take longer than they should. None connects to the others. The computing models use queueing theory. The cognitive models use attentional resource theory. The organizational models use communication complexity. Each explains its own domain and is silent on the rest. This paper formalizes the overhead as a single computable quantity derived from system structure — the topology of shared resources and competing activities — applicable across all domains. The tool is a graph. The result is an equation. The vocabulary is small and builds in order. Processing is what any system does when it must act on information — a CPU executing instructions, a surgeon operating, a pilot flying, a developer debugging. The unit of processing is the **op**: one irreducible transformation by one processor. Processing entropy is the op count a specific processor requires for a specific task. The processor's total capacity is bounded by one inequality: total ops multiplied by average op duration must not exceed the available time budget. Two counting regimes apply to any processing measurement. The **isolated regime** measures one task on one pipeline with no concurrency — nothing else running, no competition, no interruption. This is where the theoretical minimum cost lives: the ops required for the task itself and nothing else. The **in situ regime** measures the same task in its real execution environment — other tasks competing for the same pipeline, shared resources occupied by others, and the full weight of the concurrent world pressing on the processor. The difference between in situ cost and isolated cost is the **concurrency tax**: additional ops, inflated op durations, and dead time generated by the execution environment rather than by the task itself. This paper shows that the concurrency tax is derivable from the structure of the system — from which resources are shared and which activities compete for them — rather than being an empirical quantity that can only be measured after the fact.