The Residual, the Local Model, and the Seam

William Kahan’s Numerical Discipline, Dr. Fawad Rauf’s Adaptive Architecture, and the WodansEye Extension

Don Gunter — WodansEye Research Series — July 2026

Draft for technical and attribution review.

Claim and attribution conventions

[REF] established external result, documented publication, or standard
[KAHAN] principle, result, design, or argument attributable to William M. Kahan and collaborators
[RAUF] principle, result, design, or argument attributable to Dr. Fawad Rauf, Hassan M. Ahmed, and collaborators
[WE] architecture or terminology developed in the WodansEye research program
[DM] structural mapping between bodies of work; resemblance is asserted, identity is not
[SYN] new synthesis proposed here
[CONJ] testable conjecture or engineering proposal
[PENDING] requires implementation, measurement, or review by the named researcher

This paper keeps William Kahan primary. His work supplies the established numerical-computation floor.
Dr. Fawad Rauf’s work enters where the subject crosses from numerical residuals into adaptive local models, changing systems, dynamical error, and layered implementation.
The WodansEye contribution is the independently developed seam, carry ledger, TDIL record, E-tree routing, shell promotion, connection-density constraint, and typed translation architecture applied around those established foundations.

Status and verification note

Citations verified. The load-bearing citation — Rauf & Ahmed 1997, “New Nonlinear Adaptive Filters with Applications to Chaos,” International Journal of Bifurcation and Chaos, 7(8), 1791–1809 — was independently confirmed against a third-party reference list matching journal, volume, page range, and year exactly. The Kahan references are his established Berkeley publications, correctly described.

[PENDING] tags bearing Dr. Rauf’s name are discharged. Dr. Rauf reviewed the passages that credit his and Hassan M. Ahmed’s work and confirmed them fair, accurate, and correctly bounded; his 1993 entries match his record of that year. His full review is published as a companion response, and his own account of the two intellectual genealogies appears as “The Two Paths.”

A correction about sequence, on the record. An earlier draft of this note stated the paper was “ready to send to Dr. Rauf, not yet cleared to post.” In fact it was posted before that review completed — in a venue not only Dr. Rauf could see, but posted nonetheless, ahead of the sequence the note prescribed. Dr. Rauf caught this and was right to: in a paper whose central law is that nothing should be committed before it can be closed honestly, the publication process is itself a computation, and the path matters there too. The order was violated; the outcome was fortunate rather than earned. This note records the fact rather than quietly repairing it, because the alternative would reproduce in the meta-record exactly the error the paper argues against.

Abstract

William M. Kahan spent his career demonstrating that a mathematically valid expression is not yet a reliable computation. The path matters: representation, evaluation order, rounding, underflow, overflow, branch cuts, exceptional values, compiler transformations, working precision, diagnostics, and the ability to retain a residual all participate in the answer. His work on IEEE 754, stable formula evaluation, compensated summation, signed zero, gradual underflow, fused operations, iterative refinement, and numerical debugging forms the primary foundation of this paper. [KAHAN]

Dr. Fawad Rauf’s earlier work with Hassan M. Ahmed addressed a neighboring but distinct problem: how to construct practical nonlinear adaptive behavior from simpler local filters. Their work used state-dependent embedding, layered and locally connected structures, fast recursive adaptation, parallel implementation, and adaptive prediction of chaotic systems. Their architecture moved complexity from one monolithic nonlinear unit into the selection, connection, and adaptation of competent local units. [RAUF]

The WodansEye program arrived independently through a different line: typed seams, bounded reference frames, the Carry Ledger, entropy banking, TDIL prediction records, E-tree routing, scale-shell promotion, useful connection density, exact reference backends, and a general translation object T. [WE] The discovery of Rauf’s earlier work changes the attribution ledger. Some structures previously treated as broadly architectural must now be separated more carefully: locally adapted nonlinear filtering, state-dependent embedding, layered local models, fast recursive adaptation, and dynamical-error analysis belong to Rauf, Ahmed, and their collaborators. The E-tree, TDIL, carry grammar, shell-routing law, typed unresolved state, and translation library remain WodansEye constructions unless prior art shows otherwise.

The new synthesis is a residual-governed architecture with three distinct responsibilities:

1. Kahan: preserve numerical meaning, control rounding seams, and compute trustworthy residuals.
2. Rauf: adapt competent local models to changing nonlinear dynamics and monitor model motion.
3. Gunter/WodansEye: type the unresolved state, route it across local models and scales, retain provenance, and choose when to promote, defer, approximate, or invoke an exact reference path.

The central proposed law is:

Do not ask one scalar, one local model, or one representation to carry information it cannot preserve. Retain the residual, type the failure, change the route or reference, and return only when the answer can be closed honestly.

Author’s note on discovery and credit

I encountered Kahan through a practical failure in Heron’s formula. The naive expression and the stable expression were algebraically equivalent, but one cut directly through a finite-precision cancellation seam and the other routed around it. That was immediately recognizable in the language I had already been developing around seams, carry, exact ledgers, and choosing the operational path rather than blindly executing the written formula.

I encountered Dr. Fawad Rauf only recently.

That discovery matters.

His recent public vocabulary — layers, tokens, tensors, context, reference, local models, machines, minds, and energy — ran close to language in my own work. Then I found his earlier engineering publications with Hassan M. Ahmed. Those papers addressed the hard implementation problem decades earlier: constructing nonlinear adaptive behavior from state-dependent, locally connected, locally adapted structures, including fast recursive adaptation and prediction in chaotic systems.

I will not retroactively absorb that work into mine.

Where this paper uses local adaptive models, successive linearization, state-dependent embedding, layered nonlinear filtering, fast recursive adaptation, or dynamical error, the prior engineering lineage is Rauf and Ahmed. Where this paper uses stable floating-point evaluation, signed zero, gradual underflow, compensated accumulation, iterative refinement, directed rounding, or the numerical-environment argument, the primary lineage is Kahan.

My contribution is the attempted joining mechanism:

• a typed unresolved state rather than forced classification;
• a carry ledger rather than discarded residue;
• TDIL records for short history, prediction, uncertainty, residual, and horizon;
• E-tree routing among local, lateral, parent, skip, and return relations;
• shell promotion when the current reference cannot close the operation;
• useful connection density rather than maximum connection;
• a generic T library in which numerical, adaptive, symbolic, and generated operations carry explicit contracts.

This paper is therefore not a priority claim over Kahan or Rauf.

It is a convergence report, an attribution correction, and a proposal for an experiment.

Part I — William Kahan: computation is not algebra written on a machine

1. The whole stack participates in the answer

Kahan’s work is often reduced to “Kahan summation” or “the floating-point standard.” That misses the scale of his project.

The real object of study was the complete numerical environment:

mathematical problem
    ↓
chosen formulation
    ↓
algorithm
    ↓
evaluation order
    ↓
number representation
    ↓
instruction semantics
    ↓
compiler transformation
    ↓
hardware execution
    ↓
diagnostic and recovery interface
    ↓
reported answer

A failure anywhere in that chain may appear at the end as “rounding error,” although the actual cause could be:

• an ill-conditioned problem;
• an unstable formulation;
• premature rounding;
• abrupt underflow;
• overflow in an intermediate;
• loss of branch-side information;
• expression reassociation;
• an unintended fused operation;
• a language that hides the arithmetic environment;
• a test suite that never visits the dangerous region;
• or a result type incapable of representing the exceptional state.

[KAHAN] IEEE 754 was therefore not merely a storage format. It was an attempt to create a coherent arithmetic environment in which ordinary software could behave reasonably and expert software could interrogate and control the arithmetic when necessary.

This is the first major lesson for E-tree:

Numerical meaning is a cross-layer contract.

A graph optimizer, source generator, JIT compiler, or agent cannot treat arithmetic expressions as free algebra if the path through finite representation is part of the result.

2. Condition is not stability

Kahan’s treatment of needle-like triangles teaches a distinction that must become explicit throughout the WodansEye work.

Conditioning

Conditioning belongs primarily to the problem.

It asks:

How much can the true answer change when the input changes slightly?

Stability

Stability belongs primarily to the algorithm.

It asks:

How much additional error does this computational path create beyond the sensitivity already present in the problem?

A well-conditioned problem may be damaged by an unstable algorithm. A badly conditioned problem may defeat even a stable algorithm unless the output includes an uncertainty or condition estimate.

The naive Heron formula illustrates the first case. A triangle may have a meaningful, well-determined area, while the direct evaluation of s - a loses the low-order distinction that carries the answer. Kahan’s sorted and reparenthesized form follows another path through the same algebra. [KAHAN]

The WodansEye mapping is strong but must remain correctly tiered:

[DM] Kahan’s stable Heron path is a classical example of routing around a destructive seam.

It is not proof that the WodansEye Half-Center Seam theorem generated Kahan’s result or that the two formalisms are identical. It is a prior, established instance of the same engineering shape:

direct path crosses a finite-precision fold
    → distinction annihilates
equivalent path preserves separated factors
    → answer survives

3. Signed zero: a boundary value can carry direction

IEEE 754 preserves both +0 and -0.

They compare equal as ordinary real values, but their signs may encode which side of a branch cut or discontinuity was approached. In complex elementary functions, erasing the sign can erase the side of the cut and therefore select the wrong continuation. [KAHAN]

This is a powerful precedent for the WodansEye treatment of zero:

[REF] Zero need not be an informationless scalar.

The stronger WodansEye claims — zero as a seam opcode, division-boundary routing, parent jumps, or non-identity 0/0 behavior—are not established by IEEE 754. They remain separate proposals.

But Kahan’s work establishes the lower-level design principle:

A representation may need to preserve direction or provenance at a value that ordinary algebra regards as identical.

That matters for E-tree types. A future boundary value may require fields such as:

value
approach direction
source scale
reference frame
exception class
continuation rule
provenance

The scalar alone may be insufficient.

4. Gradual underflow: do not manufacture zero early

Abrupt underflow maps a sufficiently small nonzero result directly to zero. Gradual underflow uses subnormal values to preserve a diminishing distinction until the format truly runs out of representable resolution. [KAHAN]

The important property is not that subnormals preserve full relative accuracy. They do not.

The important property is that they often preserve:

x - y = 0  if and only if  x = y

across a much wider useful domain than abrupt underflow.

The WodansEye correspondence is:

[DM] Gradual underflow is an established arithmetic example of refusing to commit a false zero while recoverable distinction remains.

This is close to the Carry Ledger rule:

cannot express fully at current scale
    ≠
nothing exists

The system should retain a reduced-precision distinction, a residual, a carry, or a typed unresolved state rather than inventing equality.

5. Compensated summation: the dropped part belongs in the state

Ordinary floating-point addition returns a rounded sum. Some low-order information does not fit in the committed result.

Compensated summation retains a correction term that estimates or exactly recovers part of what the current addition lost, then uses that correction in later steps. [KAHAN]

The conceptual state is not:

sum

It is:

visible sum
+
banked correction

This is the closest established numerical ancestor of the Carry Ledger and Entropy Banking.

The mapping is not identity:

• Kahan’s correction term belongs to a particular summation algorithm.
• The Carry Ledger attempts a wider grammar of carry, borrow, cancellation, lane state, deferred promotion, and register capacity.

But the shared law is clear:

[DM] Information that does not fit in the current committed result should not automatically be discarded. It may be retained as typed state and reconciled later.

That principle belongs in the base T contract.

A translation may return:

value
residual
status

rather than only value.

6. Iterative refinement: error becomes a control signal

In iterative refinement, an approximate solution is tested by computing a residual:

r = b - A x

A correction is then computed and applied. Extra precision may be needed primarily in the residual, not throughout the entire solve. [KAHAN]

This is one of the most important bridges in the paper.

The residual has at least four roles:

1. it measures what the current answer failed to satisfy;
2. it detects whether the current representation is sufficient;
3. it guides a correction;
4. it supplies a possible stopping or confidence criterion.

The WodansEye program uses the same general shape in several places:

• Carry Ledger correction;
• TDIL surprise delta;
• exact reference backend supervising a fast path;
• shell promotion after local failure;
• contradiction debt and later repair;
• retained provenance for rollback or regeneration.

Kahan’s lesson is not “perform the whole computation at maximum precision.”

It is:

Spend fidelity where the residual controls repair.

That is a direct correction to any broad claim that exact arithmetic is simply free.

Exact arithmetic has a cost. The more defensible principle is:

Preserve exactness or extra precision at the boundary where losing it would force expensive repair throughout the rest of the system.

7. Parentheses, contraction, and compiler authority

Kahan’s numerical formulas often preserve parentheses for a reason. A compiler that reassociates expressions under real-number algebra may destroy the intended rounding sequence.

Likewise, a fused multiply-add changes two rounding points into one. This is often beneficial, but an algorithm written under assumptions about separate rounding may need to be rewritten to exploit the fused operation correctly. [KAHAN]

For E-tree and T, this means a mathematical expression requires an execution contract:

reassociation:
    forbidden | bounded | permitted

contraction:
    forbidden | declared FMA only | permitted
rounding:
    nearest | upward | downward | toward zero | dynamic
working precision:
    exact | binary32 | binary64 | extended | selected
exception policy:
    flag | typed return | trap | saturate | propagate
parallel reduction:
    deterministic | bounded variation | unrestricted

The AST cannot discard grouping as presentation trivia when grouping determines the finite result.

The CST cannot always erase parentheses after semantic analysis.

The optimizer must know when algebraic freedom has been narrowed by a numerical promise.

8. The hidden cost is lifecycle cost

Kahan repeatedly argued that the cost of arithmetic is not exhausted by a benchmark loop. Missing precision or inaccessible arithmetic features export cost into the rest of the project:

special cases
epsilon comparisons
NaN guards
clamps
retry paths
precision promotion
duplicate safe and fast implementations
platform-specific branches
mysterious regression tests
field failures
maintenance labor

This is the deeper form of the hare-and-tortoise story.

The FPU hare is not evil. It is often the correct engine.

The failure occurs when the system counts only the hare’s local instruction cost and ignores the caravan of programmers carrying patches behind it.

The tortoise is not arbitrary precision everywhere. It is disciplined retention:

• preserve what is cheap and decisive;
• approximate where approximation is permitted;
• name the rounding boundary;
• retain enough residual to repair;
• do not make every downstream programmer rediscover the seam.

Part II — Dr. Fawad Rauf: complex behavior from competent local models

9. The prior engineering lineage

Dr. Fawad Rauf’s early publications with Hassan M. Ahmed include work on:

• nonlinear adaptive filtering;
• parallel and systolic implementation;
• dynamical error in nonlinear filtering;
• adaptive bilinear inverse filtering;
• adaptive state-dependent filters;
• fast recursive adaptation for nonlinear filters;
• adaptive prediction of chaotic systems;
• a layered implementation based on successive linearization;
• computationally efficient nonlinear filters with applications to chaos.

[RAUF] Their 1993 state-dependent-filter work described a method in which nonlinear filter structures could be represented through state-dependent embedding and a layered structure. [RAUF] Their locally connected nonlinear-filter architecture emphasized modularity, parallelism, local adaptation, and implementation efficiency. [RAUF] Their later chaos work applied successive linearization and adaptive prediction to systems whose own dynamics challenge the estimator.

This territory overlaps materially with TDIL and the shell architecture.

The overlap must be credited.

The following should not be described as uniquely WodansEye inventions:

• obtaining nonlinear global behavior from locally adapted simpler units;
• selecting or embedding local behavior according to state;
• layered nonlinear adaptive filtering;
• fast recursive local adaptation;
• using adaptive predictors on chaotic systems;
• treating source dynamics as part of estimator error;
• designing local connectivity for parallel or hardware-efficient implementation.

Those belong to the earlier adaptive-filter literature, including Rauf and Ahmed.

10. Successive linearization as an architectural pattern

Let the underlying system be:

x(t+1) = F(x(t), u(t)) + η(t)

where F is nonlinear and may change regime.

A monolithic model attempts to approximate F across the complete operating domain.

A local-model architecture instead uses a family of simpler models:

M_r(z, u) = A_r z + B_r u + b_r

with an addressing or embedding law:

r = ρ(z, context)

The combined predictor becomes:

x_hat(t+1) = M_ρ(z,context)(z(t), u(t))

The global mapping is nonlinear even though the active local calculation may be relatively simple.

This creates a different placement of complexity:

monolithic nonlinear unit

becomes:

local models
+
state-dependent selection
+
adaptation
+
connectivity

That architecture is important for E-tree because it suggests that the intelligence may live less in one universal operator and more in:

• address;
• local competence;
• residual;
• transition policy;
• return path.

11. Model motion contains information

An adaptive model has at least two visible outputs:

1. the prediction;
2. the motion of its own parameters.

A predictor may remain temporarily accurate only because its coefficients are changing rapidly to chase the source.

Therefore:

small output residual

does not necessarily imply:

stable regime

A useful controller should also track:

parameter drift
covariance or confidence
effective local instability
model-switch frequency
time since local fit was established

This is a direct lesson for TDIL.

A revised TDIL record should distinguish:

prediction error
model adaptation rate
reference mismatch
sensor uncertainty
dynamic transition risk

The model’s motion may warn before the output visibly fails.

12. Dynamical error is not ordinary noise

In nonlinear and chaotic systems, prediction error may arise not only from sensor noise or poor coefficients but from the source dynamics themselves.

Nearby trajectories may separate rapidly. A local model may be valid only over a bounded horizon. A state may be approaching another attractor, region, or regime.

This suggests a layered error ledger:

Δ_total =
    Δ_numeric
  + Δ_sensor
  + Δ_reference
  + Δ_model
  + Δ_dynamic
  + Δ_cross_scale

Each term calls for a different response.

Numerical residual — Kahan domain

The mathematical operation lost information because of representation, order, underflow, overflow, or rounding.

Response: stable reformulation, extra precision, compensation, interval, directed-rounding probe, exact reference, or typed exception.

Sensor residual

The observation is noisy, delayed, missing, aliased, or corrupt.

Response: estimate, filter, fuse another channel, or request another observation.

Reference residual — WodansEye domain

The observation is being interpreted at the wrong scale, chart, center, or semantic frame.

Response: change reference, promote shell, cross a seam, or retain unresolved status.

Model residual — Rauf domain

The active local model family is inadequate for the current state.

Response: adapt, switch, widen, create another region, or increase local model order.

Dynamical residual — Rauf domain

The source is transitioning or locally unstable.

Response: shorten horizon, increase transition risk, avoid forced commitment, and prepare another local model.

Cross-scale residual — WodansEye domain

Two competent models disagree because they operate over different windows or scales.

Response: coordinate, retain both, promote, and return a constraint downward.

This decomposition is one of the paper’s main proposed contributions.

Part III — The WodansEye contribution

13. The typed unresolved state

A binary decision often forces one of two outputs:

left | right

The E-tree adds an operational third state:

left | unresolved/carry | right

The middle state does not mean “no data.”

It means:

The current reference cannot resolve this state without destructive compression.

The system may then:

• wait;
• gather another sample;
• consult another local model;
• route laterally;
• promote to a broader shell;
• invoke an exact or higher-precision reference;
• or preserve both alternatives until another constraint arrives.

This is not supplied by Kahan or Rauf in this form.

It is the WodansEye routing contribution.

14. Carry Ledger and entropy banking

The Carry Ledger treats deferred arithmetic information as explicit state.

Its core engineering law is:

Do not force carry, borrow, cancellation, or promotion through a boundary when the system can retain the relation and settle it at a cheaper or more informative checkpoint.

Kahan supplies the established numerical precedent through compensation and refinement.

Rauf supplies the adaptive precedent that local models can remain simple while the organization handles nonlinear complexity.

The Carry Ledger extends the residual principle into:

• lane-level state;
• run grammar;
• cancellation corridors;
• deferred promotion;
• reusable capacity;
• register and bus switching;
• operation scheduling by structural relation.

The extension remains WodansEye work, but its roots must now be presented honestly.

15. TDIL: the local temporal record

The Temporal Dendritic Inference Layer assigns each input channel or local model a short bounded record:

history
prediction
residual
uncertainty
coherence
confidence

After the Rauf intersection, that record should expand to include:

local_model_id
local_parameters
parameter_drift
numeric_status
effective_instability
predicted_horizon
transition_risk
route

After the Kahan intersection, it should also distinguish:

computed value
numeric residual
model residual
exception flags or typed states
working precision
rounding path
reference backend comparison

TDIL therefore becomes more than a temporal cache.

It becomes a local truth-maintenance record for a bounded translation.

16. E-tree shells: where unresolved work changes reference

The shell architecture separates local control complexity from total system capacity.

Get Don Gunter’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Lower shells may operate with:

• short history;
• small local models;
• fast execution;
• low energy;
• narrow context.

Upper shells may preserve:

• longer history;
• broader state partitions;
• cross-domain constraints;
• alternate references;
• exact or expensive backends;
• longer-horizon models.

A local operation follows a provisional route:

resolved numerically
+ resolved by local model
+ sufficient horizon
    → commit locally

numeric residual too large
    → stable form / compensation / precision promotion
model residual too large
    → neighboring or broader local model
parameter drift rising
    → mark transition risk
reference residual present
    → seam or shell change
no safe assignment
    → carry without commitment
resolved at broader shell
    → return constraint downward

This is the proposed joining layer.

17. Useful connection density

Rauf’s locally connected structures reduce indiscriminate global wiring.

The E-tree adds parent, neighbor, skip, and return relations.

The Connection Density Hypothesis argues that the goal is not maximum connectivity but recoverable, calibrated relation under cost.

For an edge e, let:

w_e = importance
r_e = recoverability
c_e = coherence
q_e = calibration
x_e = present relevance
cost_e = maintenance, movement, and retrieval cost

Then a design objective is:

D_useful =
    Σ(w_e r_e c_e q_e x_e)
    ---------------------
          Σ(cost_e)

This is not claimed as a universal theorem. [CONJ]

It gives the combined architecture a wiring objective:

• enough local connection for efficient adaptation;
• enough cross-scale connection for recovery;
• no obligation to connect every unit to every other unit;
• explicit cost for keeping a relation alive.

18. T: the common executable object

The new E-tree translation library uses one base abstraction:

T : INPUT_DOMAIN -> OUTPUT_DOMAIN

A T may be:

• a mathematical function;
• a stable numerical formula;
• a compensated accumulator;
• an exact reference path;
• a local adaptive filter;
• a mux;
• a scanner;
• a parser;
• a symbol pass;
• a pretty printer;
• a p-code-like operation;
• an LLVM/JIT lowering;
• an agent tool.

The Kahan-Rauf intersection shows that a numerical or adaptive T requires more than input and output types.

A proposed contract is:

TContract {
    input_type
    output_type

    state_model
    effect_model
    consumption_law
    production_law
    activation_law
    numeric_format
    working_precision
    rounding_policy
    underflow_policy
    overflow_policy
    exceptional_state_policy
    reassociation_permission
    contraction_permission
    parallel_reduction_policy
    local_model_id
    adaptation_law
    parameter_drift_metric
    prediction_horizon
    residual_schema
    reference_backend
    provenance
    conformance_suite
}

Not every T uses every field.

The metamodel determines the relevant subset.

This is where the historical work becomes reusable rather than rediscovered.

Part IV — The three-way synthesis

19. The residual ladder

The combined architecture can be organized as a residual ladder.

Level 0 — Numeric execution
    Kahan:
    Is the chosen finite-precision path trustworthy?

Level 1 — Local adaptive model
    Rauf:
    Does the active local model still fit the changing source?
Level 2 — Reference and scale
    WodansEye:
    Is the state being interpreted in the correct shell or chart?
Level 3 — Cross-model coherence
    WodansEye:
    Which local or wider relations are worth activating?
Level 4 — Synthesis and action
    E-tree T:
    Which result can be committed, generated, or executed honestly?

Each level can return:

resolved
residual
typed failure
promotion request

This prevents the common anti-pattern:

every failure → NaN, zero, exception, or one generic confidence score

Instead, the failure carries enough type information to select a repair.

20. The Kahan–Rauf–E-tree loop

A proposed execution loop is:

Step 1 — Select a local T

r = route(state, context, shell)
T_r = local_translation[r]

Step 2 — Execute under a numeric contract

result = T_r(input, numeric_contract)

Step 3 — Record numerical status

numeric_record = {
    value,
    residual,
    rounding_path,
    exception_state,
    precision_used
}

Step 4 — Update the local adaptive model

prediction_error = observed - predicted
parameter_drift = distance(theta_t, theta_t-1)

Step 5 — Estimate horizon and transition risk

horizon = H(local_instability, uncertainty, accepted_error)

Step 6 — Classify the residual

numeric
sensor
reference
model
dynamic
cross_scale
mixed

Step 7 — Route rather than erase

close locally
compensate
reformulate
promote precision
switch local model
route laterally
promote shell
carry unresolved
invoke exact reference

Step 8 — Return repaired context

The broader or more exact path does not replace the fast local model permanently unless the evidence requires it.

It returns:

correction
constraint
new local model
new route
updated confidence

The local path then resumes.

21. The hare, the gray-beard, and the local guide

The engineering image now has four figures.

The hare — fast finite hardware

The FPU runs quickly and usually correctly within the promised domain.

The gray-beard — Kahan’s numerical discipline

He moves the parentheses, preserves branch-side information, retains a correction, requests a residual, changes precision locally, and refuses compiler transformations that violate the arithmetic contract.

The local guide — Rauf’s adaptive model

He knows this region of the nonlinear terrain. He adapts as the source moves and warns when the model itself is moving too quickly to remain trustworthy.

The ledger keeper — the E-tree controller

It records which guide was active, what residual remained, what scale was used, where the unresolved state traveled, and what correction returned.

The tortoise does not defeat the hare by being slow.

The complete team wins because speed is allowed where speed is safe, local adaptation is allowed where the local model is competent, and the residual is carried when neither can honestly close the answer.

Part V — Immediate research and implementation program

22. Experiment A: static numerical seam

Use formulas with known dangerous regions:

• Heron area;
• quadratic roots;
• hypot;
• log1p;
• expm1;
• vector norms;
• dot products;
• variance;
• complex branch-cut functions.

Compare:

naive T
stable Kahan-style T
compensated T
scaled T
exact/reference T

Measure:

• absolute and relative error;
• condition estimate;
• exception states;
• sensitivity to rounding mode;
• sensitivity to compiler optimization;
• cycles, memory traffic, and energy proxy;
• downstream guard code required.

Purpose:

Establish the numerical residual layer.

23. Experiment B: local nonlinear adaptation

Use standard changing systems:

• logistic map;
• Hénon map;
• Lorenz system;
• a nonlinear system-identification target with controlled parameter drift.

Compare:

global linear adaptive model
global nonlinear model
fixed local models
Rauf-style locally adaptive layered model

Measure:

• one-step error;
• multi-step error;
• parameter drift;
• transition detection lead time;
• adaptation cost;
• local activation sparsity;
• prediction horizon.

Purpose:

Reproduce the Rauf layer faithfully before extending it.

24. Experiment C: residual typing and shell routing

Add E-tree routing around the locally adaptive models.

Compare:

Rauf local models only
Rauf local models + generic threshold switch
Rauf local models + typed residuals
Rauf local models + typed residuals + shell promotion
Rauf local models + TDIL horizon + exact numerical reference

Measure:

• false promotions;
• missed transitions;
• recovery time;
• prediction horizon calibration;
• correct decisions per activated model;
• correct decisions per joule;
• number of unresolved states forced into false classifications;
• useful connection density.

Purpose:

Determine whether E-tree routing adds measurable value beyond the established local-model architecture.

Run this experiment first. On Dr. Rauf’s review, Experiment C is the one that decides the paper. It is the direct test of whether the routing layer adds value beyond what the local-model architecture already provides. If typed residuals and shell promotion do not outperform a generic threshold on the measures above, the honest conclusion is that Kahan and the adaptive-filter literature already contained the machine, and the WodansEye contribution is the map rather than the mechanism. A good map is a genuine contribution — it is what lets a builder see two traditions as one architecture — but it must be labeled as a map and not as a new engine. The order of experiments is therefore C, then A and B as its numerical and adaptive baselines, then D. [PENDING]

25. Experiment D: compiler and JIT conformance

Represent the stable numerical formulas and adaptive updates as T graphs.

Lower them through:

• direct C++;
• table/interpreter form;
• generated source;
• LLVM IR;
• JIT;
• vectorized and parallel variants.

Test contracts:

strict
contracted
fast

Verify:

• parentheses and operation order;
• FMA policy;
• rounding-mode behavior;
• exception-state propagation;
• deterministic and nondeterministic reduction;
• equivalence to reference backends;
• effect of -ffast-math-class transformations.

Purpose:

Prove that E-tree can preserve numerical and adaptive meaning through translation.

26. Primary falsifiers

The synthesis should be rejected or narrowed if:

1. typed residual classification does not outperform a simpler scalar threshold;
2. shell promotion adds cost without improving recovery, horizon, or sparse activation;
3. parameter drift does not provide useful transition warning;
4. exact or compensated reference paths cost more over the measured lifecycle than the errors they prevent;
5. the T contract cannot survive realistic compiler and JIT lowering;
6. useful connection density fails to predict a better architecture than ordinary sparsity or fixed topology;
7. the proposed mappings confuse established Kahan or Rauf mechanisms with WodansEye terminology without adding a testable mechanism.

A convergence that produces no better measurement remains an educational analogy.

That is acceptable, but it must be labeled correctly.

Reviewer’s challenge, recorded

Dr. Rauf’s review identified the paper’s real contribution as the six-term residual taxonomy of Section 12 — numeric, sensor, reference, model, dynamical, cross-scale, each with its own repair — on the ground that the most common failure in engineered systems is not the presence of error but the collapse of every error into one undifferentiated scalar, after which the correct repair can no longer be selected. A typed failure is half a repair. If the experiments show nothing else, showing that typed residuals outperform a generic threshold would justify the architecture.

He also named the paper’s vulnerability precisely: in Parts III and V the ratio of vocabulary to measurement is too high, and every load-bearing claim there currently sits under [CONJ]. That is the paper’s own falsifier 7 returned to it by a reviewer, and it is accepted without reservation. The names — Carry Ledger, TDIL, E-tree, shell promotion — earn their place only when Experiment C reports a number. Until then they are scaffolding, and this paper does not pretend otherwise.

Part VI — Attribution ledger

27. What belongs primarily to Kahan

• IEEE 754 numerical-environment discipline;
• stable evaluation of dangerous formulas, including needle-like triangles;
• compensated summation;
• signed-zero and branch-cut significance;
• gradual underflow as preservation near zero;
• directed rounding as a diagnostic tool;
• iterative refinement and accurate residual use;
• criticism of unsafe reassociation and hidden arithmetic environments;
• lifecycle-cost argument for strategically available extra precision;
• insistence that hardware, language, compiler, algorithm, and diagnostics form one numerical system.

28. What belongs primarily to Rauf, Ahmed, and collaborators

• successive linearization for nonlinear adaptive filtering;
• state-dependent embedding;
• layered nonlinear-filter structures;
• locally connected and locally adapted filters;
• parallel, systolic, modular, and hardware-oriented implementation;
• fast recursive adaptation;
• adaptive state-dependent filters;
• adaptive signal processing for chaotic systems;
• analysis of dynamical error and transition behavior in nonlinear adaptive prediction.

29. What belongs to the WodansEye program, subject to continued prior-art review

• Half-Center Seam terminology and the broader seam-routing grammar;
• Carry Ledger, entropy banking, and lane-granular deferred promotion;
• TDIL as a per-channel short-history, short-prediction, residual, uncertainty, and coherence record;
• E-tree trinary routing with an explicit unresolved/carry state;
• lateral, parent, skip, promotion, and return routes across scale shells;
• Connection Density as useful recoverable relation under cost;
• exact/reference backend paired with accelerated paths in the Circle–Tree package;
• the general T translation abstraction and proposed numeric/adaptive contract;
• the proposed residual taxonomy joining numerical, sensor, reference, model, dynamical, and cross-scale error;
• the combined Kahan–Rauf–E-tree experiment proposed here.

30. What remains synthesis rather than ownership

The following are not claimed as discoveries of one author:

• that residuals can guide correction;
• that local models can be organized hierarchically;
• that exact and approximate paths can cooperate;
• that prediction requires uncertainty and horizon;
• that computation has energy and maintenance cost;
• that a graph can route among algorithms.

The contribution is the specific architecture, typing, routing law, implementation, and falsification suite — not possession of every general idea it touches.

Conclusion

William Kahan remains the primary figure in this paper because he established the computational discipline beneath the whole argument.

He showed that:

• algebraic equivalence does not guarantee computational equivalence;
• a zero can carry side information;
• a tiny value should not be collapsed prematurely;
• a dropped low-order part can be retained;
• a residual can repair an approximate answer;
• a little extra precision at the right seam can save enormous system cost;
• a compiler can silently invalidate a numerical proof;
• and an arithmetic environment must be designed for diagnosis as well as speed.

Dr. Fawad Rauf’s earlier work enters at the next boundary.

He and Hassan M. Ahmed showed how nonlinear adaptive behavior can be built from simpler local filters through state-dependent embedding, layered organization, local adaptation, parallelism, and recursive updating. Their work also confronted the fact that changing and chaotic source dynamics alter what prediction error means.

The WodansEye work adds a proposed controller around those two foundations:

• preserve the residual;
• identify its type;
• retain an unresolved state;
• route rather than force;
• promote scale or precision only where needed;
• return repaired context downward;
• and record the path in a reusable translation graph.

The complete design law is:

Kahan protects the number. Rauf adapts the local model. The E-tree protects the unresolved relation between them.

Or, in operational form:

fast local execution
    + stable numerical path
    + adaptive local model
    + typed residual
    + bounded routing
    + exact or broader recovery
    + return to local action

The goal is not perfection everywhere.

The goal is a machine that knows where it is losing the answer, retains enough structure to recover it, and does not make the next generation of programmers carry the same rounding patches through every large project.

That is the gray-beard lesson.

That is the local-model lesson.

And that is where the seam becomes an architecture.

A closing note on convergence

Dr. Rauf, in review, traced a fact this paper could not have known to state. The two foundations joined here descend from genealogies that share no ancestor in the twentieth century. Kahan’s numerical discipline runs through Byron Griffith at Toronto back into the Synge school of classical mechanics. The adaptive-architecture line runs through Hassan Ahmed to Martin Morf to Thomas Kailath to Jack Wozencraft to Robert Fano — into the founding circle of information theory. Two surveyors, different continents, different instruments, the same summit.

The synthesis proposed in this paper stands where those two independent traditions, having never met in lineage, meet in architecture. That is worth stating plainly, and it raises the stakes of the experiment rather than lowering them: if the routing layer proves to be a map rather than a machine, it is still a map drawn at the one point where two traditions converge, and that convergence is itself the evidence that the summit is real. But whether the map is also an engine is a question only measurement answers, and Experiment C is where the answer is.

The seam is real. The work now is to stand on it honestly — to run the experiment that tells the map from the machine, and to label whichever it turns out to be.

Recommended reading path

William M. Kahan — primary

1. Kahan, William M. — “Mathematics Written in Sand.”
   Triangle area, exact subtraction, gradual underflow, numerical environments, and the argument that hardware-supported mathematics can simplify reliable software.
   https://people.eecs.berkeley.edu/~wkahan/MathSand.pdf
2. Kahan, William M. — “Miscalculating Area and Angles of a Needle-Like Triangle.”
   Direct foundation for the stable Heron work and the distinction between condition and algorithmic instability.
   https://people.eecs.berkeley.edu/~wkahan/Triangle.pdf
3. Kahan, William M. — “How Futile Are Mindless Assessments of Roundoff in Floating-Point Computation?”
   Compensated summation, diagnostic rounding, compiler reassociation, and testing discipline.
   https://people.eecs.berkeley.edu/~wkahan/Mindless.pdf
4. Kahan, William M. — “A Brief Tutorial on Gradual Underflow.”
   Why preserving tiny distinctions near zero matters.
   https://people.eecs.berkeley.edu/~wkahan/ARITH_17U.pdf
5. Kahan, William M. — “On the Cost of Floating-Point Computation Without Extra-Precise Arithmetic.”
   Strategic extra precision versus the lifecycle cost of workarounds.
   https://people.eecs.berkeley.edu/~wkahan/Qdrtcs.pdf
6. Kahan, William M. — “How Java’s Floating-Point Hurts Everyone Everywhere.”
   Signed zero, branch cuts, language design, arithmetic control, and iterative refinement.
   https://people.eecs.berkeley.edu/~wkahan/JAVAhurt.pdf
7. Kahan’s Berkeley publication index.
   https://people.eecs.berkeley.edu/~wkahan/index.htm

Dr. Fawad Rauf and Hassan M. Ahmed — adaptive intersection

1. Ahmed, H. M., and Rauf, F. — “Parallel, Locally Connected Algorithms for Nonlinear Adaptive Filtering.”
   International Journal of High Speed Electronics and Systems, 1993.
   DOI: https://doi.org/10.1142/S0129156493000066
2. Ahmed, H. M., Rauf, F., and Khurram, M. U. — “Adaptive State Dependent Filters.”
   ICASSP 1993, pp. 436–439.
   IEEE record: https://ieeexplore.ieee.org/document/319528
3. Rauf, F., and Ahmed, H. M. — “Adaptive Signal Processing Techniques for Chaotic Systems.”
   ICASSP 1993, pp. 563–566.
   DOI: https://doi.org/10.1109/ICASSP.1993.319560
4. Rauf, F., and Ahmed, H. M. — “New Nonlinear Adaptive Filters with Applications to Chaos.”
   International Journal of Bifurcation and Chaos, 7(8), 1791–1809, 1997.
   DOI: https://doi.org/10.1142/S0218127497001370
5. Rauf publication index at DBLP.
   https://dblp.org/pid/86/252.html

Companion pieces by Dr. Fawad Rauf

• Dr. Fawad Rauf — “Review and Response: On ‘The Residual, the Local Model, and the Seam.’” His technical and attribution review of this paper: the ledger confirmed, the [PENDING] tags discharged, the six-term taxonomy named as the real contribution, and the vocabulary-to-measurement vulnerability identified.
• Dr. Fawad Rauf — “The Two Paths.” His account of the two intellectual genealogies this paper joins: Kahan’s numerical-analysis lineage (through Byron Griffith at Toronto to the Synge school of classical mechanics) and the adaptive-architecture lineage (through Hassan Ahmed to Martin Morf to Thomas Kailath to Jack Wozencraft to Robert Fano, into the founding circle of information theory). Two traditions that share no twentieth-century ancestor, meeting in architecture rather than in lineage.

WodansEye companion works

• Don Gunter — The Local Model and the Shell
• Don Gunter — The Carry Ledger
• Don Gunter — The Connection Density Hypothesis
• Don Gunter — Scale-Shell Ordering
• Don Gunter — The Quotient and the Seam
• Don Gunter — The Circle, the Tree, and the Gray-Beard Engineer
• Circle–Tree package — exact/reference arithmetic, NLMS, Heron conformance, and the developing E-tree translation library

WodansEye Research Series — Don Gunter — July 2026

Research synthesis and source verification assistance: ChatGPT, Reviewer 1. Technical and attribution review: Dr. Fawad Rauf, who confirmed the ledger, discharged the [PENDING] tags bearing his name, and named the six-term taxonomy as the paper’s contribution and the vocabulary-to-measurement ratio as its vulnerability. Editorial formatting and citation verification: Claude.

Attribution status: Kahan primary; Rauf/Ahmed explicitly credited where their adaptive-filter architecture is load-bearing, and their review incorporated; WodansEye claims restricted to the independently developed structures and the new synthesis proposed here, with the load-bearing routing claims held under [PENDING] until Experiment C reports.