Value Logic: A Pragmatic Theory of Successor Models

This project was developed and written with substantial assistance from GPT‑5.6 Sol, especially on the formalism, experiments, and audits. Fable 5 performed audits as well as proposed the notation that was eventually used for license / adequacy.

This is just the companion Substack essay: The full technical paper is available in the public Gist. You can also visit the public GitHub repository to see how the entire project was developed.

Newton’s laws are false. Or, at least, they are “false” in the familiar sense that they are not universally correct. Relativity and quantum theory exposed limits that Newtonian mechanics cannot cross.

But college students still learn Newton’s laws. Engineers still use them. For a bridge, a machine, a ball in flight, or a spacecraft maneuver far from relativistic extremes, the older theory may be accurate enough, cheaper to apply, easier to inspect, and better matched to the available measurements than its more fundamental successor.

So what does “superseded” actually mean?

It apparently does not mean “throw this model away.” An older model can lose its claim to unrestricted finality while remaining extremely useful inside a restricted domain. In fact, the reason we keep using Newtonian mechanics is precisely that it has value there. Using the successor theory would buy us little or nothing for many ordinary problems, while costing more effort.

I expect the same kind of thing to happen again. The Standard Model is extraordinarily well tested and also known to be incomplete—it does not include gravity, for one thing. We believe our best theories may eventually be replaced by theories we do not have yet. I don’t know whether that process ever ends, and this project doesn’t answer that question. The possibility that it continues is the philosophical motivation.

Either way, we have a practical problem. We have to use models before we know whether they are final. “True” and “false” are not always enough to express the decision we actually need to make. What I want to be able to say is something narrower:

This versioned plan may presently be relied on for this purpose, on this domain, under these constraints, using this evidence, with this fallback if the evidence is not good enough.

I call that judgment a license.

A model has pragmatic value when a versioned plan using it is useful for a declared task and context. It might earn our reliance because it predicts accurately enough, runs quickly, remains robust, uses inputs we actually have, keeps its errors within the tolerance of the decision, or improves on the best available alternative. Usually we care about several of these at once.

The compact way to write the first part is something like “model M is adequate on domain D within tolerance ε.” M and D are easy enough: we are evaluating some model on some restricted domain. But where did ε come from? What kind of error are we measuring? Are we taking an average, protecting the worst case, or worrying about rare catastrophic failures? What units are we using?

The paper calls the aggregation rule a domain functional. This sounds more exotic than it is. A local loss gives us a loss for each case. The domain functional takes that whole case-by-case loss rule and returns the domain-level number we intend to compare with a threshold. It might return expected loss, worst-case loss, or tail risk. It is called a functional because its input is itself a function. The choice matters: changing it changes which patterns of error we care about.

Sometimes the threshold comes from an external precision or safety requirement. Sometimes it comes from the status quo. Suppose the fallback B has expected loss .35 on the domain, and I require a new plan to improve on it by at least .05. Then the fallback-relative ceiling is .30:

εB(D) = J(B,D) − Δ

Here B is what happens if no candidate is selected, Δ is the required improvement, and J is the declared domain-level loss or cost. This is one perfectly ordinary place an ε can come from.

It also shows why “better than the fallback” and “good enough in absolute terms” are different requirements. A terrible fallback may be easy to beat while the new plan remains unacceptable. A plan can also satisfy an absolute error limit without improving enough on an unusually good fallback. We may want both conditions, plus limits on latency, cost, robustness, traceability, or something else.

The thing receiving a license can be larger than one equation or neural network. It might be a finite plan: choose a frame, run a fitted model, translate its output, estimate a loss, route between experts, and finally produce an action. Two such plans can make the same prediction while differing in cost, robustness, provenance, and the way errors propagate.

For that reason, I keep three things separate: the ordinary computational payload, a quantitative grade or bound, and the evidence that makes the grade usable. I also distinguish the actual task loss from a model that estimates that loss, and both from the optimization loss used to train the estimator. These distinctions are fussy, but they prevent several genuinely different numbers from quietly turning into “the loss.”

The formal request has four parts. There is an evidence state, meaning the finite records and provenance available now; an executable plan, meaning what would actually run; a reliance context, which fixes the task, domain, loss, aggregation, thresholds, constraints, fallback, units, and evidence mode; and a profile, which is the checklist of requirements for this kind of reliance.

Is four the minimum possible number? No interesting result could depend on that, because we could always bundle fields together. I use four because it lets evidence change without replacing the plan, lets the plan change without redefining the task, and lets us strengthen the standard of authorization without pretending the underlying evidence changed.

The rest of the project then proceeds in a few different ways. The calculus gives a constructive account of restricted reliance, revision, composition, and local update. ReLU networks give one finite representation of the numerical interface. A synthetic experiment tests one particular structured pipeline. And the policy–value bridge, which is still the most speculative part, has a clean finite existence result alongside much harder questions about semantic reconstruction in practice.

Here is the small example I use throughout the paper. In ordinary English, the request is:

“May we use this plan on the declared domain, given the records accepted now, if its loss is at most .20, it improves on the fallback by at least .05, it finishes within 50 milliseconds, and its version and evidence chain are traceable?”

Suppose an older plan and a broader successor are both candidates. The fallback has loss .35, so the improvement clause requires the candidate’s loss to be at most .30. Notice that this is still weaker than the absolute ceiling of .20. We have not allowed “better than what we were doing” to become a synonym for “good enough.”

Now suppose the accepted loss interval for the older plan is [.14, .18], and its latency interval is [43, 47] milliseconds. The successor has loss [.11, .16] and latency [45, 49] milliseconds. Assume both trace records are accepted.

What should happen? Both plans satisfy the three numerical requirements. I do not think the logic should invent a unique winner. Their licensed domains can overlap. A later selection policy can choose by cost, speed, robustness, or another declared criterion. If neither plan is licensed, the system uses the named fallback or takes an explicit information-gathering action.

I ended up with four public outcomes because there are four importantly different things we may need to do next.

If the request itself is malformed—its units do not match, for example, or a required fallback was never specified—the result is Undefined. The request has to be repaired.

If the request makes sense but some required evidence is missing, expired, conflicted, or straddles a decision boundary, the result is Withheld. We need more or better evidence.

If accepted counterevidence establishes that a requirement is violated, the result is Refused. We should revise the plan or choose another one.

Only when the request is well formed and every required condition is supported is it Granted. Even then, “Granted” only admits the plan to later selection. It does not necessarily mean “this is the one plan you must use.”

Individual requirements have their own states: Supported, Open, and Refuted. Granted, Withheld, and Refused summarize a complete well-formed request. Undefined is reserved for the malformed one.

Could a very simple controller collapse these into “use” and “fallback”? Of course. An auditor may want a dozen finer distinctions. Four is not a metaphysically special number. It is just the coarsest public interface I found that preserves these four different responses.

The distinctions become especially useful when the evidence changes. If the older plan’s latency certificate expires, the plan becomes Withheld; nothing needs to become retroactively false. If later loss evidence moves to [.23, .25], the adequacy requirement becomes Refuted and the request becomes Refused. If the threshold changes from .20 to .16, the old interval [.14, .18] crosses the new boundary and becomes Open, while the successor’s [.11, .16] remains Supported at equality.

This gives us a fairly natural picture of supersession. A later specialist can become preferred on one subregion without erasing the older models from every other region, or from the archive.

Some of my original global rules turned out to be too broad. This is where the formal work was most useful: the corrected versions are more constructive.

A profile is just a typed checklist. A basic reliance profile asks whether the candidate is adequate, improves on its fallback, satisfies its constraints, and has a usable trace. A preferred-use profile can ask one more thing: whether, among the exact finite set we evaluated, there is no certified dominator. Here a dominator is no worse on every declared comparison coordinate and strictly better on at least one.

Why keep those in different profiles? Because a newly added superior model may defeat the claim that this one is preferred without changing the fact that this one is adequate. It also lets a bounded search make an exact claim about the finite set it actually checked, instead of pretending to have proved global optimality.

Partial domination does not magically split a domain into clean child regions, either. We can split only if we can reconstruct the child domains along with their evidence, samplers, fallbacks, and provenance. If we cannot, the unresolved region remains Withheld or goes to fallback.

Likewise, the library we preserve does not have to be its Pareto frontier—the eligible plans not dominated by another eligible plan. We may keep a dominated model for historical explanation, recovery, or use under a different profile. Adequacy, lack of a known dominator, frontier membership, archival retention, and current selection are five different things. They coincide only under additional choices about the library, resource coordinates, comparison completeness, and retention policy.

There is also an asymmetry in an open-ended library. A present claim that “no known model dominates this one” can be overturned tomorrow by adding a dominator. But once an existing certified dominator has refuted that comparison, adding more models does not make the dominator disappear. My earlier slogan that open-ended comparison is never stable was therefore wrong in a useful way. Positive non-domination and persistent refutation behave differently.

The neural motivation came from a very simple observation. A threshold gives us a signed margin. ReLU turns the positive part of that margin into a nonnegative feature. And finite continuous piecewise-linear computations can be represented exactly by finite feed-forward ReLU networks, assuming the usual architectural conventions.

Why is that interesting? Suppose a network remembers an estimated loss rather than only remembering which side of today’s threshold it fell on. If I change the tolerance tomorrow, the numerical statistic may still be useful. A three-way label produced for the old threshold has already discarded some of that information.

This suggested a bridge between the logic and an actual computation. A network could propose losses, intervals, grades, or ordinary payloads. Exact external machinery could then validate the evidence, apply the boundary rule, preserve missingness and provenance, combine the requirements, mask unlicensed candidates, and call the fallback when necessary. A named positive-margin channel could have two uses: it could tell us how far we are inside a supported boundary, and it could feed a later declared computation.

What does the exact theorem give us? Representability. It does not tell us that gradient descent will learn the representation efficiently, that this architecture is uniquely appropriate, that activation regions line up with scientific domains, or that arbitrary hidden units have semantics. One licensed region may contain many activation cells, and one activation cell may contain several licensed models.

There is also a more general result that does not care whether the representation is a neural network. Start with the downstream questions the representation has to answer; I call that the consumer family. A representation is sufficient when every declared consumer can recover what it needs. The coarsest exact code merges two states exactly when no declared consumer needs to distinguish them.

This makes “how many states do we need?” a question with an answer relative to a use. Four public outcomes are minimal only for a consumer that truly needs to distinguish malformed, refuted, open, and supported requests. A Boolean use-or-don’t-use consumer needs less. An auditor who needs witnesses, signed margins, validity, and provenance needs more. Counting realizable query states can lower-bound a fixed-length discrete code. Turning that into a neural-width bound would require additional assumptions about precision and robustness.

This is where the theorems begin to matter to the opening philosophical story. Separating evidence from the world lets us represent present warrant without pretending we have reached the end of inquiry. The composition theorem says when certified components can support a composite plan. The read-footprint theorem tells us exactly which later changes leave an earlier assessment unchanged. The routing and transfer results tell us what must be preserved before usefulness on one restricted domain can be carried into a selected subdomain or successor plan. And the fixed-point boundary tells us where the finite theory stops.

Several boundaries turned out to matter well beyond ReLU networks.

First, operational support is not automatically a fact about the world. The same finite evidence record may be compatible with worlds in which the target claim is true or false. To move from the record to a world or population claim, we need a named evidence mode plus a soundness bridge: assumptions and validation connecting one to the other. A license is a finite-stage warrant. It is not a truth oracle.

Second, granting the components does not grant their composition. Two components can each have certified error .06 under separate .10 limits and still produce .12 error at the root when their errors add in the same direction. A finite acyclic plan can be certified when its interfaces match and its constructors transform payloads, grades, and evidence correctly, but the root still needs a checked certificate or a valid propagation rule.

Downstream sensitivity may amplify upstream error. The correct global bound therefore follows products of sensitivities along the paths, and it has to remain valid on the whole “perturbation tube”: all intermediate values reachable under the certified upstream errors. Latency, peak memory, energy, caching, and contention need their own aggregation rules. Throwing all of them into a single scalar sum would hide the actual engineering question.

Third, append-only history does not preserve every grant. A new model can leave all old records untouched while changing a comparison such as “no known model dominates this one.” The useful theorem is local: if an update writes outside the complete read footprint of a diagnostic, that diagnostic is preserved.

A read footprint includes every record, collection, and index lookup that can affect the answer—even a query whose current answer is “nothing found.” Otherwise inserting a new record can create a change that appears to come from nowhere. If there is no impact path from the update to the diagnostic, the diagnostic is invariant. Proving the reverse direction requires an update that can actually change the status in question.

Fourth, fallback is not the same thing as safety. An empty active set prevents the use of an unlicensed library plan, which is good. But the fallback itself may be harmful. Router risk depends on how often routing and fallback occur and on how bad those outcomes are. A low average loss on a parent domain cannot simply be copied onto each selected subdomain, because the loss may be concentrated on exactly the subset the router chooses. Routing accuracy alone is not enough; we need selected-scope loss, misroute frequency and severity, fallback mass and loss, and coverage.

Fifth, two models being close in their raw predictions does not automatically make them close in task risk, and it certainly does not make their blend safe. To transfer a prediction bound into a loss bound, the models need a common frame and something like a certified Lipschitz condition: over the reached range, task loss changes by at most a fixed multiple of prediction change. A blend is a new plan. It gets evaluated as one.

Finally, a genuine cycle cannot be licensed by calling it finite composition. If granting a plan changes the evidence or loss used to decide the grant, the resulting equations may have no fixed point or several. A recurrent extension would need an explicit state space, operator, convergence or fixed-point rule, selection convention, and evidence-to-world bridge. I leave the ordinary core finite and well founded.

This is the point where a very tempting story has to be corrected. Let us return to the running example and start with the English rather than the symbols:

“The plan’s expected loss on this domain is at most .20.”

“The plan improves on the declared fallback by at least .05; because the fallback loss is .35, the plan’s loss is at most .30.”

“The plan finishes within 50 milliseconds.”

The paper calls one typed requirement an atom. I call these A for absolute adequacy, I for improvement over the fallback, and C for the latency constraint. Their numerical subprofile is P = A ∧ I ∧ C. The symbol ∧ just means “and”: all three requirements must be Supported. A large surplus on one cannot buy forgiveness for failure on another.

The complete request also needs a valid trace and must be well formed. I chose these three numerical atoms because they show three ordinary sources of a threshold: an absolute task limit, a comparison with the status quo, and a resource constraint. There is nothing universal about having exactly three.

For plan M, suppose the accepted loss interval is [.14, .18] and the latency interval is [43, 47] milliseconds. To compare unlike quantities, I choose simple scales that make them dimensionless: (.20 − .18)/.01 = 2 for adequacy, (.30 − .18)/.01 = 12 for improvement, and (50 − 47)/1 = 3 for latency.

The .01 loss scale and the 1-millisecond latency scale are teaching choices. They are not constants of logic.

Because smaller is better in all three cases, the support slack is the threshold minus the accepted upper endpoint. Normalize it, then rectify it by replacing a negative result with zero. We get the surplus vector 2, 12, 3.

All three atoms are Supported. If the request is well formed and its trace is accepted, the request is Granted. Notice that the same loss interval answers both A and I; only the threshold changes. This is exactly the kind of numerical information a compact implementation might reuse.

But it has to carry more than the three numbers. It also needs the support and refutation directions, exact state, evidence validity, missingness, provenance, and the address—the typed identity connecting a requirement to its scope, criterion, parameters, and evidence mode.

Now hold the adequacy threshold at .20. The interval [.14, .18] gives strict support and surplus 2. The interval [.17, .20] is also supported because equality is included, but its positive surplus is zero. The interval [.18, .22] crosses the threshold and is Open, also with zero surplus. The interval [.23, .25] is Refuted, again with zero support surplus, but with a distinct positive refutation margin. Missing evidence and expired or rejected evidence are Open for different diagnostic reasons; any stored numerical zero is only a masked placeholder and has no margin meaning.

So what does a zero mean? By itself, almost nothing. Boundary support, an interval crossing the boundary, refutation, missing evidence, and invalid evidence can all produce the same rectified support value. A negative support margin is not automatically refutation. Even separate positive-support and positive-refutation channels cannot distinguish equality from an open or missing case unless the exact state travels beside them.

The interpretation has to climb a ladder.

At level one, an arbitrary positive ReLU activation tells us only that its preactivation was positive. That is all.

At level two, a positive value from a named learned point or interval margin means predicted favorable slack. The predictor may be wrong. The number is not evidence yet.

At level three, after we have accepted an envelope—a validated uncertainty region—and its evidence mode, a positive normalized value means strict certificate-relative surplus for one addressed condition, scope, version, and polarity. Polarity here means the support-or-refutation direction that the evidence is allowed to establish.

At level four, we still do not have a full license until the request is well formed and every requirement is exactly supported. A positive adequacy feature cannot compensate for missing latency evidence, failed improvement, invalid provenance, or a malformed request.

At level five, a selector may use the surplus—but only after it has restricted itself to the exactly licensed active set. For 2, 12, 3, one illustrative ranking rule is max(0, .5 × 2 + .1 × 12 + .2 × 3 − 1) = 1.8.

Relative to one unit of normalized improvement surplus, this gives adequacy five times the weight and latency twice the weight, then charges a fixed entry cost of 1. I chose those coefficients to make the example transparent. They are not logical constants, fitted moral weights, or a hidden theorem.

The resulting 1.8 ranks a candidate that is already licensed. It cannot grant the license. If the latency evidence disappears, the adequacy and improvement channels may still produce a positive downstream score, just as a network bias or bypass can remain active when one ReLU is zero. Authorization and quarantine come from the exact state, profile, active mask, and fallback—not from the sign of one neuron.

This leaves us with a real dual-use result. A named, normalized, certificate-relative surplus can be both a meaningful grade and an input to a declared downstream computation. Arbitrary hidden units and arbitrary payloads do not inherit that meaning.

There is one more mundane complication: changing units changes the raw margin. Cross-channel use therefore needs a registered normalization that changes with the units, or a downstream consumer whose coefficients change inversely. Otherwise measuring latency in seconds instead of milliseconds could change the decision, which would be absurd.

I tested two complete pipelines on a synthetic model-succession task.

The structured pipeline predicted centers and radii for loss and latency. It then used held-out calibration data—which were not used to fit the model—to expand the proposed intervals before applying the exact evidence and license decoder.

The comparison pipeline used a capacity-matched ReLU trunk with direct three-class cross-entropy heads for the meaningful atom states, followed by the same exact nonlearned operations. Both pipelines received the declared tolerance as an input. Neither got to see oracle intervals, latent world intercepts, oracle labels, outcomes, routes, or target-derived certificate information.

What did I expect? The preregistered aggregate hypothesis required the structured pipeline to win by at least .05 when the tolerance changed, win by at least .05 on a boundary panel, and remain within .02 of the direct classifier on ordinary in-regime fidelity.

That did not happen. Instead, the effects were large in opposite directions. This is what I mean by “mixed”: not weak, noisy, or inconclusive.

The changed-tolerance result was extremely encouraging. Without retraining, structured fidelity was .9436, compared with .7570 for direct cross-entropy. The paired difference was +.1866, with a 95 percent paired interval from .1860 to .1873.

The scorer saw the new tolerance and answered the changed query. So the result demonstrates changed-tolerance generalization against this particular frozen direct classifier. We did not test literal reuse of one invariant region, and we did not compare against every plausible tolerance-conditioned classifier.

The other two results went hard in the other direction.

At the boundary, the structured pipeline scored .5196 while direct cross-entropy scored .7808. The difference was −.2612, with interval [−.2636, −.2587]. That missed the preregistered +.05 win and reversed it by a large amount.

In ordinary in-regime fidelity, the structured pipeline scored .7764 against .8773, a difference of −.1009 with interval [−.1022, −.0997]. It also failed the .02 noninferiority allowance. The reverse advantages for the direct classifier are strong descriptive results, although I had not preregistered them as separate confirmatory reverse-superiority hypotheses.

The structured proposals did pass their separately registered marginal coverage checks. Loss coverage was .9098, with a 95 percent interval from .9085 to .9111 and a Holm-adjusted lower bound of .9085. Latency coverage was .9044, with interval [.9031, .9058] and lower bound .9033. Both cleared the registered .88 margin.

This sounds like good news, and it is—at the precise level it measures. The intervals marginally contained their targets in two frozen exchangeable target groups. It does not by itself establish conditional coverage, full-profile coverage, selected-route performance, deployed loss, safety, or a target-world claim. Calibrating proposed intervals and making useful licensing decisions are two different achievements.

The operational statistics make the gap obvious. The declared target distribution contained .35 true Granted mass and .65 true non-Granted mass. Target-weighted fallback mass was .9962 for the structured pipeline and .9139 for direct cross-entropy. Their target-weighted issued-Granted masses were .0038 and .0861. Issued-Granted mass may include false grants, so it is not recall. Both systems often declined to decide; the structured one fell back on almost everything.

The unweighted design-distribution traces tell the same story from another angle. The structured pipeline had low false-support and false-refutation rates, .0087 and .0146, but large missed-support and missed-refutation rates, .4611 and .3248. Accuracy conditional on the reference result being Granted was .0124 for the structured pipeline and .1811 for direct cross-entropy.

Those last two figures are unweighted design-distribution conditional accuracies. They are not target-weighted recall. The compact traces did not preserve the weights needed to decompose target-weighted fidelity or reconstruct target-weighted conditional Granted accuracy.

One part worked exactly as intended: inactive selection was zero for both pipelines. The active mask never selected an unlicensed plan. That establishes exclusion integrity, which is narrower than useful coverage or low fallback risk.

Why did the structured pipeline abstain so often? The most plausible explanation is conservative dead-band geometry. Its predicted intervals were wider on average than the oracle intervals, and the decoder sends any interval crossing a threshold to Open. Because equality counts as support, even a small overshoot of the upper endpoint can change Supported to Open.

This mechanism fits the low false-assertion rates, high miss rates, and nearly total fallback. But I cannot assign causality to it from this experiment. We compared two complete pipelines. The difference could come from the training objective, center fit, radius fit, calibration expansion, threshold construction, decoder, generator, or interactions among them. Marginal target coverage does not prove endpoint overshoot case by case. The tolerance input also contains information about how the synthetic query was constructed. Calling the result an identified “wrapper effect” would therefore be too strong.

There was one design drift I think is important to retain. An earlier plan called for comparing boundary behavior at matched coverage. The frozen primary endpoint instead compared raw macro fidelity while the systems abstained at very different rates. That is still a valid comparison of the two complete pipelines we actually froze. It is not a clean comparison of representation quality at equal answer rates.

A better follow-up would preregister full risk–coverage curves or compare at common answer rates. It should also retain target and design weights, evidence mode, polarity, diagnostics, route, fallback loss, and misroute severity.

So what is the main result?

Remembering the number helped when the rule changed. The structured pipeline beat the direct classifier by .1866 on changed-tolerance fidelity. That supports the information-retention interpretation, although the experiment did not isolate information retention as the cause.

The same pipeline lost by .2612 at the boundary and .1009 in regime, missed the noninferiority allowance by .0809, and sent .9962 of target-weighted mass to fallback. These are not cosmetic failures. This particular combination of center-and-radius outputs, marginal calibration, and conservative exact decoding was not operationally competitive on the frozen target population.

That result hits one contingent implementation of the idea. It leaves the formal reliance calculus and finite representation theorem intact, along with the observed changed-tolerance advantage.

There are several obvious next things to try: retain the statistic alongside an explicit state head; use asymmetric or boundary-aware regions; train with losses that price misses and fallback as well as false assertions; tune decoder conservatism on a separately declared validation role; or compare systems along risk–coverage curves at a common answer rate. A factorial experiment could vary the training objective, interval parameterization, calibration, and decoder separately.

The lesson I would keep is that information preservation, marginal calibration, cautious withholding, and good operational decisions are separate achievements. We should measure them separately.

This project grew out of another question I have been interested in for a while. Suppose we begin with a capable but opaque policy: in the most general case, a black box that maps states to actions, or maps states to later states through an environment. Can we turn that into something with semantic content?

Value was the first candidate that seemed straightforward enough to pursue. A value-like surrogate could give us a readable model of rankings, expected outcomes, counterfactual choices, domains of validity, and uncertainty. This would not be complete transparency. But it would be a semantic foothold—perhaps the first thing we could recover and then use to work backward. “Beliefs,” for example, did not offer me an equally obvious reconstruction route.

Does an arbitrary policy have a uniquely “true” utility function? I don’t know. If it does, would this method recover that true utility rather than one useful equivalent or approximation? I don’t know that either. The practical target is an environment-relative surrogate whose behavioral fidelity, semantic content, and domain of validity we can actually assess.

One formal existence result is quite clean. With finite states and legal actions, encode a deterministic policy as a one-hot action-score table. At each state, give the chosen action a 1 and every other legal action a 0. Add a fixed decoder with a specified tie rule. The encoder and decoder are then inverse on the encoder’s image.

This is a genuine finite isomorphism—a lossless correspondence—once we say exactly which objects and structure we are preserving. It is an existence claim. Difficulty reconstructing a natural value function in practice does not refute it.

The harder question is whether the scores can have the familiar semantics of expected return. A policy alone does not determine a standard return-based value function. We also need an environment, rewards or preferences, a state or history representation, a horizon or discount, a perspective, a terminal convention, and a decision rule.

A Q function gives each action at a state a return-based score, and greedy decoding picks the largest one. Applied to a policy’s own Q function, that decoder recovers the policy only where the policy is already greedy under compatible conventions. Elsewhere, it may improve the policy rather than invert it. A scalar state value needs a transparent action-and-transition harness. So the natural reconstruction problem is about environment-relative semantics, identification, and practical fidelity. The finite encoding result remains an existence result.

Some of my earlier intuitions needed correction here as well.

State-visitation frequency is not utility in general. An agent may visit an unavoidable or absorbing bad state constantly. A preferred terminal state may have low occupancy precisely because reaching it ends the episode. Occupancy is still a meaningful behavioral statistic, but reading it as return requires supplied rewards or preferences, adequate support, and a declared environment and horizon.

A value representation also need not be at least as complex as the policy under every accounting convention. If all actions have equal return, the value can be constant while an arbitrarily complicated policy breaks the ties. Any serious complexity comparison has to count the decoder and environment harness, fix an approximation tolerance, and assume enough action separation to recover the chosen action.

And an improving agent does not necessarily revise its terminal values. It may improve its world model, estimator, search, or policy while keeping its objective fixed. Value change can happen in some architectures. Generic improvement does not force it.

There is one more bridge from my earlier work on recursive judgment. The informal slogan was that good judgment may recover factual structure. The result I can actually prove is narrower, and I think more interesting, because it is quantitative.

Let R be a report made before an outcome, Y the held-out outcome, and N the declared nuisance context—the background information a baseline may use without R. The true N-conditioned Bayes predictor is the population-optimal probabilistic forecast based on N alone. If a predictor using R and N beats it in population log loss by δ nats, then R contains at least δ nats of conditional information about Y. A nat is simply a natural-log unit of information.

If the comparison is against a convenient baseline rather than the true Bayes predictor, we have to subtract the baseline’s regret. Under an additional mediation assumption—that the remaining report–outcome dependence passes through the latent task given N—the bound transfers to the outcome-identifiable task quotient. This quotient groups together task labels that induce the same outcome distribution.

What does that give us? Partial information about the outcome, and under mediation, partial information about the task distinctions visible through outcomes. It does not automatically give us ontology, causal mechanism, human transparency, or deployment validity.

Omitted nuisance variables, a non-Bayes baseline, direct outcome leakage, duplicate task labels, unstable outcome kernels, and recursive copying can all create trouble. A later report adds evidence only when it contributes information beyond the earlier reports. A perfect copy can agree perfectly and add nothing.

For now I keep behavioral fidelity, value fidelity, outcome or task-quotient information, domain validity and useful coverage, representational alignment, causal faithfulness, and human inspectability as separate axes. Doing well on one is not a coupon that upgrades the others.

I ended up with a hybrid architecture, and I now think this is one of the main results.

The learned parts may propose statistics, uncertainty regions, payloads, grades, or ranking utilities. The exact parts preserve each requirement’s address—its scope, criterion, parameters, and evidence mode—along with units, profile, evidence identity, permitted evidential direction, validity, provenance, and fallback. An external decoder decides Supported, Open, or Refuted for each requirement, computes the public result, constructs the active mask, and allows selection only from the licensed set.

Why not ask a network to learn all of it? Because missingness, provenance, inclusive equality, evidence validity, request formation, and fallback are exactly the places where a convenient continuous approximation can change the meaning of the decision. The network can propose. The exact interface authorizes.

A finite ReLU network gives one explicit witness when the desired numerical map is globally finite and continuous piecewise affine, or has an explicit extension of that form. Other architectures can implement the same interface. Questions of width, efficiency, learning, alignment with scientific domains, and mechanistic interpretation remain empirical.

At the formal level, the calculus gives us a way to make present reliance explicit while leaving future revision open. It distinguishes current permission, long-term stability, and semantic finality. It gives constructive stability when the relevant dependencies are frozen, or when statistical intervals eventually separate from a threshold and stay separated under declared assumptions. Complete typed read footprints make updates local. Proof-carrying composition works for finite plans when payloads, grades, and evidence are transformed correctly. Overlap, gaps, routing, and fallback become ordinary objects in the theory rather than embarrassing exceptions to a forced winner.

How much of the opening intuition survived?

The most basic part survived constructively: old and new models can remain useful on overlapping restricted domains; present reliance can be represented without being made permanent; and later evidence can revise one part of the assessment without rewriting everything.

Local persistence, finite composition, and representation sufficiency now have conditional theorems whose assumptions tell us what actually needs to be built or checked.

The experiment gave the information-retention intuition one strong piece of evidence: retaining a numerical statistic transferred much better when the tolerance changed. The complete structured pipeline then performed substantially worse at the current boundary and in regime, and fell back almost everywhere. The interesting conclusion is not that one result cancels the other. It is that retaining information and turning it into a useful present-day decision are different problems.

The policy–value project has a finite lossless encoding result and a clearer reconstruction agenda. Practical recovery of a semantically useful value-like surrogate is still work to be done.

The corrections also landed at different levels, which matters.

The counterexamples involving global closure, automatic composition, copied parent risk, and raw-prediction transfer replaced broad shortcuts with explicit premises in the formal theory.

The ReLU examples showed that exact state and evidence have to travel beside numerical margins. They changed the proposed interface.

The experiment showed that one particular center-and-radius, marginal-calibration, conservative-decoder pipeline was not operationally competitive in the frozen setting. It did not erase the changed-tolerance result or the formal calculus.

The policy–value examples told us what a semantic reconstruction has to declare: an environment, a reward or preference convention, a decoder, a support condition, and an accounting rule. The information theorem gives partial outcome information under a proper baseline, with further semantic conclusions depending on further mediation and identification assumptions.

The practical warning is simple: a system can preserve useful information and still be bad at authorizing action.

But the motivating picture remains. Supersession does not force us to choose between unrestricted endorsement and throwing the old model away. An older model and its successor can both be licensed on an overlap. A gap can invoke a fallback. Expired evidence can lead us to withhold. Counterevidence can lead us to refuse. A later specialist can become preferred without erasing the history that justified earlier use.

The ambition is to make one unavoidable decision more rigorous. Before we have settled final questions about truth, value, or model semantics, what may we rely on now, for this purpose, using this evidence, within these limits—and what should happen when the answer changes?