Discrepancy-Driven Correction¶
Core Idea¶
Discrepancy-driven correction is the iterated, goal-directed loop in which a system holds a target, observes its current state, computes the signed gap between the two, selects a corrective action as a function of that gap, applies the action, and then re-observes — repeating until the gap falls below an acceptance threshold or the target itself is reconsidered. The load-bearing object is the gap. Nothing in the loop happens without a detected discrepancy, and everything that happens is in service of reducing it. The target may be a setpoint, a specification, a hypothesis-derived prediction, a plan, or an ideal behaviour; the observation may be a sensor reading, a test result, a measurement, or a judgement; the corrective action may be a control signal, a code change, a hypothesis revision, or a coached adjustment. What unifies these instantiations is not their content but their shape.
The prime is sharper than feedback in general and broader than one-shot validation. Feedback names the bare fact that outputs influence inputs — a positive-feedback loop amplifying noise is still feedback, but it is not discrepancy-driven correction, because it lacks a target. One-shot validation checks against a specification exactly once and judges; discrepancy-driven correction commits to the loop — the explicit intent to act on the gap and re-measure. The pattern is therefore the precise intersection of three commitments that no single neighbouring concept names alone: it is goal-directed (there is a target), it is iterated (there is a loop with a re-measurement step), and it is gap-driven (the action is a function of the signed discrepancy). The six structural primitives — target, observation, gap function, action selector, action application, termination condition — are sufficient to recognise the pattern wherever it appears, and a characteristic failure mode, target drift, attaches to it: the silent erosion in which the target is moved to match the observation rather than the observation moved to match the target.
How would you explain it like I'm…
Close the Gap
Close The Gap Loop
Gap-Driven Correction Loop
Structural Signature¶
the maintained reference — the current-state read-out — the signed comparison that yields a gap — the gap-keyed action selector — the action application onto the state — the loop closure with re-observation — the gap-keyed termination invariant
A process is discrepancy-driven correction when each of the following holds:
- A maintained target. The system holds a reference value, specification, prediction, plan, or ideal against which the current condition can be judged. Without a standing target there is no object that licenses calling anything a gap.
- An observation operation. Some mechanism reads the current state of the controlled object and renders it commensurable with the target — a measurement, sensing, test, or judgement that produces a comparable quantity.
- A gap function. A comparison maps target and observation to a signed discrepancy carrying both direction and magnitude (and possibly dimensionality). This gap is the load-bearing object: nothing in the loop fires absent a detected discrepancy.
- A gap-keyed action selector. The corrective action is a function of the gap — its sign, size, and structure — not a habit applied regardless. The selector's gain (how strongly action scales with gap) governs whether the loop converges, oscillates, or runs away.
- Action application and re-observation. The selected action is applied to the state, and the state is then re-observed, closing the loop. The cycle time of this closure must be fast relative to the rate at which the gap itself evolves, or no selector can converge.
- A termination invariant. The loop halts when the gap falls below an acceptance threshold (or the target is deliberately reconsidered). The characteristic failure is target drift: satisfying termination by moving the target toward the observation rather than the observation toward the target.
These components compose a closed, goal-directed loop: a target makes a gap nameable, the gap drives an action, the action is applied and re-measured, and a threshold keyed to the gap decides when the loop stops.
What It Is Not¶
- Not
feedback. Feedback names the bare fact that an output is routed back to influence an input — a positive-feedback loop amplifying noise is still feedback. Discrepancy-driven correction is the goal-directed specialisation: feedback structured around an explicit target and a signed gap that the action is keyed to. - Not
recurrence. Recurrence is mere repetition of a state or step over time; it carries no target and no gap. This prime's iteration is in service of closing a measured discrepancy, not of repeating for its own sake. - Not one-shot
validation. A single check-against-specification judges and halts. Correction commits to the loop — the standing intent to act on the gap and re-measure — which validation does not. - Not
refinement. Refinement progressively improves an artefact toward higher quality; it need not compute a signed gap against a held target each cycle. Correction is gap-keyed and terminates on a threshold, where refinement is open-ended improvement. - Not
homeostasis. Homeostasis is one biological outcome of a stabilising correction loop — a regulated variable held near a setpoint. This prime is the general loop mechanism, which can chase a moving target, revise a hypothesis, or debug a program, not only hold a constant. - Common misclassification. Calling any iterative work "correction." Tinkering without an articulated target has no gap to compute; if no signed discrepancy keys the action and no acceptance threshold terminates the loop, what is present is undirected iteration (see
iteration), not discrepancy-driven correction.
Broad Use¶
The same target–observation–gap–action–loop skeleton recurs across substrates that look unrelated at the surface. In engineering control theory the setpoint is compared to the plant output, the gap is the error signal, the controller's gain function maps error to actuation, and the loop is the closed-loop control system. In homeostatic biological regulation the setpoint (body temperature, blood glucose, blood pressure) is compared to the measured state, and the gap drives endocrine, neural, or behavioural correction on a timescale set by the slowest mechanism in the chain. In software debugging the expected program behaviour (from spec, test, or mental model) is compared to the observed behaviour, the gap is the bug symptom, the corrective action is a code change, and the loop is the edit–compile–test cycle. In differential diagnosis a leading hypothesis predicts a symptom pattern, the gap is the unexplained finding, the action is hypothesis revision plus new tests, and the loop iterates until the explanation accounts for the data. The same shape governs scientific anomaly investigation (model prediction versus observed data; the gap is the residual; the action is model revision or controlled experiment), project variance analysis (baseline versus actual; the gap is the variance; corrective actions are scope cuts, resource shifts, schedule resets), quality control (specification versus measured dimension), coaching and skill correction (ideal performance versus observed performance), iterative argument repair (claimed conclusion versus what the premises license), and predictive processing in computational neuroscience, where the gap is the prediction error and the loop runs continuously and recursively at multiple timescales. In each, the structural commitment is identical: a target that licenses calling something a gap, an iterated gap-detection and gap-closing cycle, and a termination condition keyed to the gap.
Clarity¶
Discrepancy-driven correction clarifies by separating three confusions that pre-theoretic talk fuses into "we're working on the problem." First, it separates action without a target from genuine correction: iterative tinkering without an articulated target may produce results, but the diagnostic question "what is the gap?" cannot be applied to it, and the prime forces target articulation as a first move. Second, it separates one-shot validation from iterated correction: a single check-against-spec is validation, whereas correction requires the loop and the standing intent to re-measure. Third, it separates mechanism from discipline: feedback names the bare mechanism by which outputs influence inputs, while discrepancy-driven correction is the goal-directed specialisation, feedback structured around an explicit target.
The clarifying force is sharpest when it surfaces a recurrent and structurally identifiable pathology: closing the gap by moving the target. Lowering the bar, relabelling a symptom as acceptable, or redefining the spec to match the observation all satisfy the loop's termination condition while defeating its purpose. Because the prime names target and observation as distinct objects with distinct dynamics, it makes this substitution visible as a failure mode rather than letting it pass as adaptation. The same clarity recovers the comparator: by insisting that something computes the gap, the prime forces attention to comparator quality — untestable acceptance criteria, motivated diagnosticians, and unclear baselines are all weak comparators that corrupt the loop at its source.
Manages Complexity¶
The prime reduces a large and superficially heterogeneous family of "iterative work" patterns — debugging, diagnosis, control, regulation, science, project management, quality, coaching, revision, perception — to a single diagnostic checklist: What is the target? What is the current observation? What is the gap, in sign and magnitude? What corrective action does this gap call for? What is the acceptance threshold for terminating? What is the loop cycle time, and is it fast enough relative to the rate at which the gap evolves? The same checklist serves a debugger, a clinician, a controller, a scientist, a project manager, and a coach, compressing what would otherwise be a sprawl of domain-specific practices into instances of one structural loop.
The compression is more than mnemonic, because the loop's parameters carry their own portable consequences. Loop stability is governed by the gain of the action selector: excessive gain produces oscillation or runaway, and the structural fix — reducing gain, adding integral or derivative terms, or slowing the cycle — is the same insight whether the substrate is a PID controller, a codebase, a monetary policy, or a coaching cadence. The relation between loop cycle time and gap-evolution time bounds what any correction strategy can achieve: a loop slower than its disturbance cannot converge, no matter how well-designed its action selector. And the structure of the gap — binary, scalar, or vector-valued — dictates the action selector's design, because collapsing a vector-valued gap to a scalar discards the directional information needed for efficient correction. Each of these is a complexity-managing lever the bare notion of "iterating on a problem" does not expose.
Abstract Reasoning¶
Discrepancy-driven correction trains a reasoner to interrogate any goal-directed process through a fixed set of questions. Is there an explicit target, or am I tinkering without one? What exactly is the gap — its sign, its magnitude, its dimensionality? Is the action I am taking a function of the gap, or a habit applied regardless of it? Is my loop cycle time matched to the rate at which the disturbance or target changes? Is the comparator that computes my gap trustworthy, or is it biased, untestable, or absent? And is my termination criterion a deliberate structural commitment, or an artefact of fatigue? These questions transfer because they reference only the loop's primitives, not any substrate's content.
Several reusable inferences follow from the abstract model. Matching action gain to gap magnitude — small gaps calling for small corrections — exposes the failure of one-size-fits-all responses, whether that is always recompiling from scratch, always escalating to a senior surgeon, or always cutting scope by half. Watching for target drift becomes a standing audit: periodically check whether the acceptance threshold has crept toward the observation rather than the observation toward the threshold. Decomposing vector gaps into separately addressed sub-loops preserves directional information that scalar averaging would lose. And designing the termination criterion intentionally recognises that "good enough" is load-bearing: a loop without an acceptance threshold either runs forever or terminates arbitrarily. The same reasoning that tunes a PID controller diagnoses goal erosion in personal fitness targets, because both are reasoning about the same loop.
Knowledge Transfer¶
The transferable content of discrepancy-driven correction is a set of diagnostic and design moves that practitioners across unrelated fields recognise as each other's playbooks once the shared structure is named. Making the target explicit is the first move in every substrate, because many practices treat the target as tacit; surfacing it renders the loop legible and the gap measurable. Matching action gain to gap magnitude is the same insight in a controller's PID tuning and in a coach's correction cadence. Matching cycle time to gap dynamics is the same constraint in control engineering, project planning, and macroeconomic policy. Watching for target drift is the same audit in software acceptance criteria and in personal fitness goals. Decomposing vector gaps is the same discipline whether the components are latency, throughput, and error rate, or symptoms across three organ systems. Surfacing and improving the comparator is the same move whether the comparator is a test suite, a diagnostic protocol, or a project baseline.
The depth of transfer is visible in how completely a practitioner in one substrate can read another's failures. A senior engineer debugging an intermittent distributed-system fault and a clinician working through a fever of unknown origin are running the same structural loop — name the target, observe the state, compute the gap, act, re-observe — and they fail in the same structural ways: target unclear (no written acceptance criterion; no clear chief complaint), observation impoverished (no telemetry; no relevant labs), gap miscomputed (treating overall success rate as the gap when the real gap is in a minority subclass; treating fever as the gap when the real gap is a coupled organ-system finding), action too aggressive (rewriting half the system; ordering every test in the panel), termination criterion vague (when does "good enough" hold?). Because the gap function is the same object in both, the playbook for tuning gain, matching cycle time, and auditing the comparator transfers with almost no translation. The predictive-processing literature pushes the transfer further still, treating prediction-error minimisation as the basic operation of perception and action and supplying, in the free-energy principle and active inference, a unifying mathematical framework for one substrate instance of a loop that recurs everywhere goal-directed iteration occurs. The same skeleton — and the same failure modes — recur in every goal-directed iterative practice, which is why the diagnostic moves port without re-derivation each time.
Examples¶
Formal/abstract¶
Consider a proportional-integral controller stabilising the temperature of a chemical reactor. The maintained target is the setpoint \(r = 350\,\text{K}\). The current-state read-out is the thermocouple reading \(y(t)\). The signed gap is the error \(e(t) = r - y(t)\), carrying both direction (too hot or too cold) and magnitude. The gap-keyed action selector is the control law \(u(t) = K_p e(t) + K_i \int_0^t e(\tau)\,d\tau\), which opens or closes a coolant valve in proportion to the present error and its accumulated history. The action is applied to the reactor and the temperature is re-observed on the next sample, closing the loop. The termination invariant is implicit and continuous: the loop is doing its job when \(|e(t)|\) stays inside a tolerance band. The structure exposes the canonical levers directly. If \(K_p\) is too large the loop overshoots and oscillates — excessive gain relative to gap. If the sampling interval is long relative to how fast the reactor's temperature can swing, the loop cannot converge — cycle time slower than gap-evolution time. The integral term is precisely the structural fix for a residual steady-state gap that proportional action alone leaves uncorrected. None of these diagnoses requires knowing chemistry; they follow from the loop's six primitives alone.
Mapped back: The setpoint is the target, the error signal is the load-bearing signed gap, the control law is the gap-keyed action selector, and the sampling loop is the closure with re-observation — the whole controller is discrepancy-driven correction with the parameters made numerically explicit.
Applied/industry¶
Two unrelated practitioners run the identical loop. A site-reliability engineer chasing an intermittent latency spike in a distributed service holds a target (p99 latency under 200 ms), observes the current distribution from telemetry, computes the gap (the spike's magnitude and which request class it concentrates in), selects a corrective action keyed to that gap (cap a connection pool, add a cache, roll back a deploy), applies it, and re-observes the next traffic window. A physician working a fever of unknown origin holds a target (a diagnosis that fully explains the presentation), observes labs and exam findings, computes the gap (the unexplained finding the leading hypothesis fails to cover), takes a gap-keyed action (order a confirmatory test, revise the hypothesis, start empiric treatment), and re-observes. Both fail in the same structural ways the prime names. Gap miscomputed: the engineer treats overall success rate as the gap when the real gap lives in a 2% request subclass; the clinician fixates on fever when the coupled gap is a renal finding. Action too aggressive: rewriting half the service, or ordering the entire test panel, is high gain that thrashes the loop. Target drift: quietly relabelling the latency SLO upward, or calling the fever "viral, self-limiting" to close the case, satisfies termination by moving the target to the observation. Because the gap is the same object in both, the playbook — make the target explicit, scope the gap before acting, match action gain to gap size, audit the comparator (is the telemetry trustworthy? are the labs the right ones?) — transfers between the data centre and the bedside with almost no translation.
Mapped back: Each practitioner instantiates target, observation, signed gap, gap-keyed action, and re-observation; the shared failure modes (gap miscomputation, excess gain, target drift) are exactly the loop-level pathologies the prime predicts, which is why one expert can read the other's debugging session as their own.
Structural Tensions¶
T1 — Target Integrity versus Gap Closure (sign/direction). The loop's whole purpose is to drive the gap to zero, but the gap can be zeroed two ways: move the observation to the target, or move the target to the observation. The two are indistinguishable at the termination test, which sees only a small gap. The characteristic failure is target drift — relabelling a symptom acceptable, lowering the SLO, redefining the spec to match what was achieved — declaring success while defeating the purpose. The diagnostic is to audit the target's provenance separately from the gap: a target that has moved since the last cycle should trigger scrutiny, not satisfaction.
T2 — Loop Gain versus Stability (coupling). The action selector's gain governs how hard the loop pushes per unit of gap, and where high gain takes over, the prime's convergence story gives way to oscillation and runaway — the regime where feedback's sign-and-delay analysis dominates. Reasoning goes wrong when one treats more responsiveness as strictly better: increasing gain to fix sluggishness produces hunting and overshoot that is harder to diagnose than the original lag. The diagnostic is to check whether the correction's magnitude is scaled to the gap's magnitude, or whether a fixed-size habitual response is being applied regardless of how small the discrepancy is.
T3 — Cycle Time versus Gap Evolution (temporal). Correction presupposes that the loop closes faster than the gap itself moves; when the disturbance evolves faster than the re-observation cadence, no action selector can converge and the prime stops applying. The failure is chasing a moving target with a slow loop — tuning gain endlessly when the real defect is sampling latency — and mistaking the resulting instability for a controller-design problem. The diagnostic is to compare the loop's cycle time against the gap's characteristic rate of change before touching any other parameter; if cycle time loses, no gain setting rescues the loop.
T4 — Comparator Trust versus Apparent Gap (measurement). Everything downstream rides on the gap, but the gap is computed by a comparator — a test suite, a sensor, a diagnostician, a baseline — that can be biased, noisy, or untestable. Where the comparator is corrupt, the prime faithfully closes a gap that does not correspond to reality. The failure is a perfectly tuned loop converging on a phantom: green tests over a broken acceptance criterion, a motivated clinician seeing the diagnosis they expect. The diagnostic is to ask whether the comparator is trustworthy and falsifiable before trusting any gap it reports, treating comparator quality as upstream of loop tuning.
T5 — Scalar Gap versus Vector Reality (scopal). The gap function projects the world's discrepancy onto a comparable quantity, but real discrepancies are often vector-valued — latency, throughput, and error rate at once; symptoms across coupled organ systems. Collapsing the vector to a scalar discards the directional information the action selector needs. The failure is correcting an average while the binding gap hides in a minority component: optimising overall success rate while a 2% request subclass fails. The diagnostic is to ask whether the gap has internal structure that scalar averaging is erasing, and to decompose into sub-loops where it does.
T6 — Termination versus Open-Endedness (scalar / local-global). A termination invariant lets the loop stop, but the acceptance threshold is a local judgement of "good enough" that may not serve the global objective. Set too loose, the loop quits with a real gap outstanding; set too tight, it never halts and consumes unbounded effort polishing past the point of value — the regime where diminishing returns takes over from correction. The failure is either premature closure or perfectionist non-termination, both masquerading as diligence. The diagnostic is to check whether the threshold was chosen deliberately against the cost of further iteration, or is merely an artefact of fatigue or habit.
Structural–Framed Character¶
Discrepancy-driven correction sits firmly at the structural end of the structural–framed spectrum, consistent with its aggregate of 0.0 and its structural label. It is a bare relational loop — target, observation, signed gap, gap-keyed action, re-observation, termination — and every diagnostic points the same way.
The pattern carries no home vocabulary that must travel with it: the same loop is read by a control engineer as setpoint-error-actuation, by a physiologist as setpoint-deviation-correction, by a debugger as expected-versus-observed-edit, and by a clinician as hypothesis-anomaly-revision, each in its own field's words with no imported lexicon (vocab_travels 0). It carries no inherent approval or disapproval — a correction loop is neither good nor bad until you specify what it chases; even its signature pathology, target drift, is named structurally as moving the reference rather than the observation, not as a moral failing (evaluative_weight 0). Its origin is formal: the loop is statable purely in terms of a maintained reference, a gap function, and an action selector keyed to that gap, with no appeal to human norms or institutions (institutional_origin 0). It runs indifferently in physical and biological substrates — a thermocouple-driven coolant valve and an endocrine temperature loop instantiate it without any human practice present (human_practice_bound 0). And to identify it is to recognise a loop already wired into the system rather than to import an interpretive frame: the six primitives are sufficient to spot the pattern wherever goal-directed iteration occurs (import_vs_recognize 0). On every criterion it reads structural, with no relational skeleton hiding under a borrowed frame.
Substrate Independence¶
Discrepancy-driven correction is a maximally substrate-independent prime — composite 5 / 5 on the substrate-independence scale. Its domain breadth is total: the target–observation–gap–corrective-action–loop skeleton is not translated between fields but recognised directly in each, running in engineering control theory (setpoint versus plant output), homeostatic biological regulation (body temperature, glucose, blood pressure), software debugging (the edit–compile–test cycle), differential diagnosis, scientific anomaly investigation, project variance analysis, quality control, coaching, and the predictive-processing account of perception. Its structural abstraction is complete because the six primitives — target, observation, gap function, action selector, action application, termination condition — carry no domain commitments at all; the gap is a pure signed comparison, indifferent to whether it measures a voltage, a glucose level, a test failure, or an unexplained symptom, which is why the same loop runs in a thermocouple-driven coolant valve and an endocrine feedback chain with no human practice present. Its transfer evidence is concrete and formalised rather than analogical: the free-energy principle and active inference supply a unifying mathematical framework, PID control gives portable gain-and-stability results, and a debugger can read a clinician's fever-of-unknown-origin workup as their own loop, sharing not only the structure but the identical failure modes (target drift, excess gain, miscomputed gap). Recognised everywhere, translated nowhere, the composite of 5 is fully earned.
- Composite substrate independence — 5 / 5
- Domain breadth — 5 / 5
- Structural abstraction — 5 / 5
- Transfer evidence — 5 / 5
Relationships to Other Primes¶
Parents (1) — more general patterns this builds on
-
Discrepancy-Driven Correction is a kind of Feedback
The file: 'feedback's goal-directed specialisation — feedback structured around an explicit target and a signed gap that the action is keyed to.' A strict subspecies of feedback (which has no target).
Children (2) — more specific cases that build on this
-
Calibration is a kind of, typical Discrepancy-Driven Correction
calibration's own one_liner IS this loop ('aligning output to a trusted reference by measuring deviation, adjusting to reduce it, monitoring for drift') — a target/observe/gap/correct cycle. A named instance of discrepancy_driven_correction. Tentative reparent.
-
Homeostasis is a kind of, typical Discrepancy-Driven Correction
The file: 'homeostasis is one biological OUTCOME of a stabilising correction loop... this prime is the general loop mechanism.' discrepancy_driven_correction is the broad loop of which homeostasis (constant-setpoint biological case) is a special instance. Tentative reparent — add as an additional parent of homeostasis.
Path to root: Discrepancy-Driven Correction → Feedback
Neighborhood in Abstraction Space¶
Discrepancy-Driven Correction sits in a moderately populated region (45th percentile for distinctiveness): it has near-neighbors but no dense thicket of synonyms.
Family — Memory, Records & Persistence (27 primes)
Nearest neighbors
- Maintenance Rehearsal — 0.73
- Recursive Attenuating Amplification — 0.72
- Near-Miss Normalization — 0.71
- Configuration Drift — 0.71
- Evidence-Fidelity Decay — 0.70
Computed from structural-signature embeddings · 2026-06-14
Not to Be Confused With¶
The sharpest confusion is with feedback, and the two are genuinely close because correction is a feedback loop — but a strict subspecies of one. Feedback names any arrangement in which a portion of a system's output is routed back to modify its input, with the loop's sign (stabilising or amplifying), gain, and delay as its parameters. It is agnostic about whether there is a target at all: a microphone howling into a speaker is a textbook positive-feedback loop with no setpoint, no gap, and no goal. Discrepancy-driven correction adds three commitments feedback does not require: a maintained target that licenses calling something a gap, a signed gap that is the load-bearing object, and an action selector keyed to that gap. Where feedback asks "what is returning, how strong, how delayed?", correction additionally asks "what is the target, and is the action a function of the signed discrepancy from it?" The practical payoff of keeping them apart is that feedback's failure modes (oscillation, runaway) are about loop dynamics, while correction's signature failure — target drift, closing the gap by moving the target toward the observation — has no analogue in undirected feedback, because undirected feedback has no target to drift.
A second confusion is with homeostasis, which a reader may treat as interchangeable with corrective looping because both keep a variable near a value. Homeostasis is an outcome property — a living system holding temperature, pH, or glucose within a narrow band despite disturbance — and the negative-feedback correction loop is the mechanism that produces it. Discrepancy-driven correction is the broader mechanism category: it includes the stabilising case homeostasis names but also covers loops whose target is deliberately moving (a controller tracking a ramping setpoint), loops whose action is a model revision rather than a physical correction (differential diagnosis, scientific anomaly investigation), and loops that terminate rather than persist indefinitely (a debug cycle that ends when the test passes). Reading this prime as "homeostasis" collapses its range to the constant-setpoint biological case and loses the diagnostic, design, and inferential loops that are its most distinctive instances.
A third, subtler confusion is with refinement. Both iterate toward something better, and both can look like "improving in cycles." The distinction is what governs each step: refinement is driven by a quality gradient — make it better, finer, cleaner — and need not compute a signed discrepancy against an externally held target. Correction is gap-keyed and terminates on a threshold; the action's magnitude and direction are functions of the gap's sign and size, and the loop has a definite stopping condition. A practitioner who confuses the two will tune a refinement process as if it had a comparator to audit, or treat a correction loop's target drift as benign open-ended polishing. The discriminating question is whether each cycle's action is a function of a signed gap from a held reference: if yes, it is correction (and target integrity is the thing to guard); if it is open-ended improvement toward "better," it is refinement.
These distinctions matter because the interventions differ. Diagnosing a misbehaving correction loop sends you to gain-versus-delay tuning (the feedback regime), to comparator trust, or to target-drift auditing — three different fixes that a reader who has collapsed the prime into feedback, homeostasis, or refinement cannot tell apart.
Solution Archetypes¶
No catalogued solution archetypes reference this prime yet.