11
The floor, and its sharpest piece
The deadline you didn't know you had.
§05 says the graded measures are decided by whether the right thing happened at the right moment. §01
says an EDR is a case under a clock. So the keystone computation in this system is not a form, a report,
or a model. It is this:
Given every deadline that binds this case, what is the latest moment each remaining obligation can still
be met — and which chain of constraints makes it so?
REGISTRAR · CASE TR-4118 — ATTENDED Wed · 23:40
YOUR OPOSTATE: LIVERESIDENT: SHADOWTAPE: a3f9…c1
Synthetic case — REV 0 mockup. No patient data has ever touched REGISTRAR. The center pane is the floor’s real output — python floor/closure.py prints it.
The chart — last 12h ALL FIELDS GREEN
14:52 Referral accepted — TR-4118 ✓
17:26 Huddle documented ✓
19:10 Authorization signed ✓
20:41 Hemodynamics charted ✓
22:03 Serology panel ordered ✓
23:07 OR window confirmed — Thu 06:00–10:00 ✓
Every field is green. Nothing is out of range. No timer has expired. The deadline at right appears on no screen and in no rule — it lives in the interval between six ordinary constraints.
The surfacing · 23:40 SURFACED — UNPROMPTED
No timer fired. Nobody asked.
The serology had to be drawn at 22:15 yesterday evening. It is 23:40.
Derived, not configured — and the chain is the citation:
- [L2] OR availability closes 10:00cross-clamp ≤ 10:00
- [L1] incision → cross-clamp, 45 mincision ≤ 09:15
- [L3] recovery-team mobilisation, 2 hOR scheduled ≤ 07:15
- [L2] acceptance precedes schedulingacceptance ≤ 07:15
- [L2] offer window budgeted, 3 hmatch run ≤ 04:15
- [L0] results precede the match runresulted ≤ 04:15
- [L3] reference-lab turnaround, 6 hdrawn ≤ 22:15 (−1d)
[L0–L1] federal — ships byte-identical to all 55 OPOs · [L2–L3] your site — completed on site
Surfaced to the coordinator · acknowledged 23:42 NEVER ACTS
REGISTRAR perceives, computes, and surfaces. It never determines, allocates, signs, or sends — the fence is on action, and the derivation is the citation.
The tape — including the silences
- 23:40EMITthis surfacing · margin .93
- 23:12HOLDhemodilution worksheet unfilled — deserves nothing at hour 9 · margin on record
- 22:58UN-SAIDa page about serology was forming; a lab event posted mid-formation — killed at the seam, the killed words on tape
- 22:31HOLDfamily updated 40 min ago — not the resident’s moment
- 21:47HOLDvitals drift within bounds — watched, unspoken
This shift: 2 surfacings · 41 holds · 1 un-said.
The same unfilled field deserved silence at hour two and a page at hour nine. No fixed threshold can say both — alert fatigue is a dial with no correct setting. Judgment is trained in, not configured.
resident layer: SPEC — ships off · the deterministic floor is its null
The keystone computation, in the room where it fires — synthetic case TR-4118 · REV 0 · the surfacing is floor/closure.py’s real output
A case is a Simple Temporal Network: time points joined by binary constraints of the form
a ≤ xj − xi ≤ b. Each becomes two edges
in a distance graph, and three classical facts then do all the work — the network is consistent
if and only if that graph has no negative cycle; the tightest implied bounds are its all-pairs
shortest paths in the (min, +) semiring; and the feasible window of any event falls straight out
as [ −D[j][0], D[0][j] ].
The case, as time points
| x₀ … x₃ | referral received (the reference point) · OPO response · clinical triage complete · death declared |
| x₄ … x₇ | authorization obtained · serologies drawn · serologies resulted · donor workup complete |
| x₈ … x₁₁ | match run executed · primary acceptance · OR scheduled · incision |
| x₁₂ … x₁₅ | cross-clamp · organ out and packaged · arrival at accepting centre · implant and reperfusion |
The constraints — and which layer owns each one
| Constraint | Form | Owner |
| Response to referral | x₁ − x₀ ≤ τresp | L0 · policy-defined |
| Authorization precedes allocation | x₈ − x₄ ≥ 0 | L0 · policy |
| Serology results precede the match run | x₈ − x₆ ≥ 0 | L0 · required element |
| Incision to cross-clamp | x₁₂ − x₁₁ ∈ [α, β] | L1 · surgical |
| Cold ischemia budget, organ o | x₁₅ − x₁₂ ≤ CITo | L1 · clinical |
| Reference-lab serology turnaround | x₆ − x₅ ∈ [τ⁻, τ⁺] | L3 · your lab |
| Recovery-team mobilisation lead | x₁₁ − x₁₀ ≥ τmob | L3 · your team |
| Transport to the accepting centre | x₁₄ − x₁₃ ∈ [γ⁻, γ⁺] | L3 · your logistics |
| Offer window to primary acceptance | x₉ − x₈ ≤ τoffer | L2 · your practice |
| Donor-hospital OR availability | x₁₂ ∈ [w⁻, w⁺] | L2 · your hospital |
Look at which rows bind hardest. The federal ones are real but generous. The constraints that
actually decide whether a case converts are the L2 and L3 rows — your OR window, your lab's
turnaround, your team's mobilisation time. Those are precisely the layers the completion in §09
authors. The closure is only ever as good as the fit, which is why the fit is the product and
not the record.
A worked closure
Illustrative and synthetic; no real donor data. Cold-ischemia budgets are clinical figures to be
verified against current practice, and every L2/L3 value below is exactly the sort of local fact a
site authors for itself.
given · L2The donor hospital's OR is available for cross-clamp between 06:00 and 10:00; after that it is committed to scheduled cases until 18:00.
given · L1Incision to cross-clamp: 45 minutes.
given · L3Recovery team mobilisation: 2 hours from OR scheduled to incision.
given · L2Match run to primary acceptance: up to 3 hours of offer time.
given · L3Reference-lab serology turnaround: 6 hours.
given · L0Serologies must have resulted before the match run.
Nobody wrote down a serology deadline. The closure derives one anyway:
# the binding path, read backwards off the shortest-path tree
cross-clamp ≤ 10:00 OR window closes [L2]
incision ≤ 09:15 − 45 min to cross-clamp [L1]
OR scheduled ≤ 07:15 − 2 h mobilisation [L3]
primary acceptance ≤ 07:15 must precede scheduling [L2]
match run ≤ 04:15 − 3 h offer window [L2]
serology resulted ≤ 04:15 must precede the match run [L0]
serology drawn ≤ 22:15 − 6 h lab turnaround [L3] ← yesterday evening
It is 23:40. The serology has not been drawn. Not one timer has expired and every field on
every screen is green — and the morning OR window is already gone. The next one is 18:00, which
moves the whole case eight hours downstream and into a different organ's ischemia budget.
No single field was wrong. The failure lives in the transitive closure of constraints that are
each individually satisfied, which is why a flat list of timers cannot see it and why this is the exact
failure class §05 says decides institutional survival.
The path is the citation
The chain above is not commentary. It is the shortest path that realises the bound, recovered
from the same computation that produced it. The output of this algorithm is a derivation a physician
can check in seconds — which is what "advisory by construction" has to mean if it means anything, and
what the decision-support carve-out in §12 actually requires. There is no model in it anywhere.
The code
The reference implementation is the null and it is fifteen lines. Times are whole minutes;
INF is the classical sentinel, chosen because it can be doubled without
overflowing a 32-bit integer.
# floor/closure.py — the minimal network of a Simple Temporal Network
INF = 0x3f3f3f3f # doubles without overflowing int32
def close(D):
"""D[i][j] = tightest known bound on x_j - x_i, in minutes. D[i][i] = 0.
In-place is safe: row k and column k are fixed during pass k, since D[k][k] = 0."""
n = len(D)
for k in range(n):
np.minimum(D, D[:, k, None] + D[None, k, :], out=D) # ⊗ = +, ⊕ = min
return D
def report(D):
if (np.diag(D) < 0).any():
return INFEASIBLE # a negative cycle: this plan cannot be met
return -D[:, 0], D[0] # earliest, latest — for every obligation
And the batched path, for the question a supervisor actually has at 3 a.m. — I have one perfusionist
and three cases; if I push this OR by ninety minutes, what breaks? That means re-solving the network
under every candidate intervention across every live case, which is thousands of small independent
networks: a batched tropical matrix multiply.
// floor/tropical.cu — C = A ⊗ B in the (min,+) semiring, one case per blockIdx.z
#define TILE 16
#define INF 0x3f3f3f3f
__global__ void tropical_mm(const int* __restrict__ A,
const int* __restrict__ B,
int* __restrict__ C, int n)
{
__shared__ int As[TILE][TILE], Bs[TILE][TILE];
const int b = blockIdx.z;
const int row = blockIdx.y * TILE + threadIdx.y;
const int col = blockIdx.x * TILE + threadIdx.x;
const size_t off = (size_t)b * n * n;
int acc = INF;
for (int t = 0; t < n; t += TILE) {
const int ax = t + threadIdx.x, by = t + threadIdx.y;
As[threadIdx.y][threadIdx.x] = (row < n && ax < n) ? A[off + row*n + ax ] : INF;
Bs[threadIdx.y][threadIdx.x] = (by < n && col < n) ? B[off + by *n + col] : INF;
__syncthreads();
#pragma unroll
for (int k = 0; k < TILE; ++k)
acc = min(acc, As[threadIdx.y][k] + Bs[k][threadIdx.x]); // ⊕ = min, ⊗ = +
__syncthreads();
}
if (row < n && col < n) C[off + row*n + col] = acc;
}
And then the line the whole thing is actually for:
assert np.array_equal(closure_gpu(D), closure_cpu(D)) # exact. no epsilon. ever.
Why the semiring is the correctness argument
Tropical arithmetic over integers is exactly associative. There is no floating point anywhere:
times are whole minutes, min and + are exact, and the sentinel is sized so it can be added to itself
without overflow. So the accelerated path and the deterministic floor produce bit-identical
output, by construction — not "within tolerance," not "reproducible in practice." Identical.
That is what makes a fast path admissible at all in a system whose battery includes replay
determinism and floor-with-learned-zeroed. A floating-point implementation would be quicker to write
and would silently fail both gates.
Where a graphics card honestly earns its place — and where it does not
Not on one case. A case has a few dozen time points, and a lifecycle is nearly series-parallel —
a chain with a handful of forks — so its induced width is small and the floor runs in effectively linear
time on a CPU, in microseconds. The general algorithm is cubic; the domain's structure is what makes
it cheap. Claiming a GPU is required here would be a lie.
On the portfolio sweep, it does. Fifty live cases against a couple of hundred candidate
interventions is tens of thousands of tiny networks — arithmetic that is GEMM-shaped with (+, ×)
replaced by (min, +), which is what a consumer card is for. It turns a batch job into a question you can
ask and answer while the person who asked it is still on the phone. BUDGET
And the card is already in the building: §12 puts one there for the local model. The same card runs the
solver between beats.
The null · a flat list of timers with alarms
Which is what every EDR already has, and it is not weak. The claim here is narrow: the closure catches
implied deadlines that no single timer encodes, because no individual field is wrong at the
moment a case becomes infeasible. The experiment is cheap and needs nothing but an existing tape —
replay historical cases, count the breaches a flat timer list would have missed, and print the number.
If the flat list catches nearly all of them, this section becomes a funeral and the page will say
so. NULL