Author: Wavy (github: condorstark)
We study a simple normative question: should the compute and the confidence an AI
system spends on a query scale with the difficulty of that single query, rather than
with the size of the model? We call the first regime difficulty-bound and the second
size-bound. To make "difficulty" operational we propose a per-instance object, the
Resource Triedron R_x(B, D, V), which accounts, for each input x, the compute
spent B, the semantic distortion accepted D, and the residual verification deficit
V, tied by an additive conservation lower bound B + Φ(D) + V ≥ difficulty(x).
We are explicit that the adaptive-compute and cheap-verification ideas are already
published; our contribution is not a new mechanism. The genuinely new and defensible
piece is a measurable axis of verification difficulty: L = d_min(x), the number of
sub-claims that must be read together to expose an error. L predicts the number of
random spot-checks needed, q* ~ m^(1 - 1/L), and therefore predicts whether the
deterministic-versus-randomized verification gap G_x = V_det - V grows with answer
length (decomposable regime, L small) or collapses (holistic regime, L ≈ m). On
real data, HotpotQA multi-hop questions have a small, length-independent L (mean 2.47),
placing factual natural language in the favorable regime. We report what holds, what is
conjectural, and what we did not test. This is a narrow, real result aligned with where
test-time compute and hallucination detection are already heading — not a revolution.
Contemporary large models are size-bound: a trivial query ("2+2") and a hard one are both answered by pushing activations through the same large network, at roughly the same per-token cost, with the same (uncertified) confidence. A difficulty-bound system would instead spend almost nothing on the trivial query and return a correctness certificate, while spending more compute and producing a stronger proof on the hard one.
Formalizing "difficulty" per instance is the obstacle. We take the intrinsic difficulty
of x to be the time-bounded conditional Kolmogorov complexity of its answer-witness,
C^t(y* | x): the length of the shortest program that, given x, reconstructs a correct
answer within time t. This is incomputable, so every number below is a proxy (a
compressor or a reference model's log-loss), not an absolute threshold. We state this up
front because it bounds every claim in the paper.
Before claiming novelty we audited the 2019–2026 literature. Most of the originally intended contributions are already published.
Adaptive compute on knowledge. Routing compute by query difficulty and retrieval need is established: Adaptive-RAG (Jeong et al., arXiv:2403.14403) selects retrieval depth per query; PEER (arXiv:2407.04153) and Memory Layers at Scale (Berges et al., arXiv:2412.09764) decouple stored knowledge from dense compute. The broader test-time compute line (e.g. scaling inference for hard problems) is the same idea under a different name.
Cheap proofs of output correctness. Semantic entropy (Farquhar et al., Nature 2024) detects confabulation by clustering meaning-equivalent samples; Self-Proving Models (Amit et al., arXiv:2405.15722) attach a verifiable transcript but assume a formal verifier and constant soundness; Proof-Carrying Numbers (arXiv:2509.06902) carry an attestation alongside numeric output. Conformal factuality (Mohri & Hashimoto, arXiv:2402.10978) gives distribution-free correctness guarantees.
Algorithmic foundations. The additive two-branch decomposition of difficulty is the Kolmogorov structure function (Vereshchagin & Vitányi, cs/0204037) and the algorithmic sufficient statistic (Gács, Tromp & Vitányi). That randomized verification can be far shorter than a deterministic witness is the foundation of interactive and probabilistically checkable proofs (IP, PCP, PCPP; Dinur, Ben-Sasson et al.) and of list-decoding query bounds (Rubinfeld, Saraf & Vasudevan, ITCS'21).
Conclusion of the audit. Neither "spend compute by difficulty" nor "prove the output cheaply" is new. Whatever value exists must lie elsewhere. Note also: several 2025–2026 references surfaced during ideation could not all be confirmed; we cite only the pre-2025 foundations above with confidence, and flag the rest for manual verification.
For each input x and produced answer y we define three coordinates:
B= log₂ of the FLOPs/steps spent producingy(the inference rate);Φ(D)= the Kolmogorov-structure-function branch: bits not paid by accepting distortionD = d(y, y*)(the price of quality);V= the length of the shortest attestation a randomized PPT verifier accepts with soundness errorδ_s(the price of trust).
The object is the per-instance realizable region and its lower Pareto frontier,
R_x = closure{ (B, D, V) realizable on x }. The crucial point: R_x is an invariant
of the instance x (and of the fixed machine, verifier, and metric), not of the
model. Today we measure properties of models; R_x is a geometry of the instance that
every model can only approach from above.
Theorem I (additive conservation, the ≥ direction). There is a constant c
independent of x such that on the frontier ∂R_x,
B + Φ(D) + V ≥ C^t(y* | x) − c. Sketch: a system that spends B bits of compute,
exploits Φ(D) bits of distortion tolerance, and emits a V-bit attestation is a
descriptor of y* given x of length B + Φ(D) + V + O(1); by incompressibility it
cannot fall below C^t(y* | x). This is a standard counting argument — solid but nearly
tautological. The matching achievability (a 1-for-1 exchange, slope −1) is conjectural;
only the lower bound is argued.
Define the interactive gap G_x = V_det − V ≥ 0: the shortest deterministic certificate
minus the shortest randomized attestation. If G_x grows with difficulty, V is a
genuinely independent coordinate; if G_x → 0 everywhere, the Triedron collapses to the
two-branch structure function relabeled. For structured tasks G_x large is essentially
already known (it is the content of IP/PCP). The open, decisive question is whether a
measurable, difficulty-proportional G_x exists for natural language, where there is
no formal verifier.
Decompose an answer y into m atomic sub-claims. Let
V_det= verify all of them against the evidence — costΘ(m);V= verify a random subset of sizeq— costO(q).
The quantity that governs V is the locality L = d_min(x): how many sub-claims
must be read together to notice an error. L = 1 means errors are locally visible
(isolated facts, decomposable); L = m means an error is visible only by reading
almost everything (global coherence, holistic). L is an axis of verification
difficulty, orthogonal to generation difficulty, and it is measurable.
Falsifiable prediction. The minimum number of spot-checks to catch an ε-fraction
of errors with confidence 1 − δ scales as
q*(m, ε, L) ~ m^(1 - 1/L)
L = 1:q*constant inm⇒ verification cost is length-independent ⇒G_x = m − q*grows.L = 2:q* ~ √m.L = m:q* ~ m⇒V ≈ V_det⇒G_x → 0(collapse; no gap).
For arithmetic the non-collapse is exact, not conjectural, via Freivalds' algorithm.
To attest c == a · b, draw s random primes p_i and carry (p_i, c mod p_i); the
verifier checks (a mod p_i)(b mod p_i) mod p_i == c mod p_i. A wrong c is caught by a
random prime with probability ≥ 1/2, so s primes give soundness 1 − 2^(−s). The
attestation is O(s log) bits, independent of the size of the numbers, against a
deterministic answer of Θ(n) digits — G_x grows with n. This is the structured
foothold that calibrates the instruments; it is classical, and we present it as such.
All code is stdlib-only Python and runs immediately; see Section 6.
Synthetic bench (semantic_pcp.py). A micro-world plants ⌊εm⌋ errors, each with a
detection-set of L claims; an error is caught iff all L of its claims fall in the
random sample. Measuring q* for m ∈ {16, 32, 64, 128, 256}, ε = 0.1, the log-log
slopes track the prediction 1 − 1/L closely (measured ≈ 0.1–0.15, 0.51–0.57,
0.77–0.79, 0.89, 1.00 for L = 1, 2, 4, 8, m; exact values are seed-dependent but the
spectrum is monotone increasing). This confirms q* ~ m^(1 - 1/L) and the
decomposable/holistic separation without any model.
Hard real data — HotpotQA (phase3_real.py, hotpot_L.json). For 300 multi-hop
questions we take L = |supporting_facts|, the annotated number of facts that must be
combined. We measure:
| statistic | value |
|---|---|
| mean | 2.47 |
| median | 2 |
| range | 2 – 5 |
| distribution | L2: 65%, L3: 24%, L4: 9%, L5: 1% |
The key empirical fact: real multi-hop reasoning needs to combine 2–3 facts (rarely
up to 5), and this does not grow with context size. L is a small constant. Plugging
these L into the validated simulator gives G_x = m − q* growing with answer length
for every constant L (including L = 5, where q* ~ m^0.8, so G_x = Θ(m)).
Reasoned extremes (small N, our in-context judgment, not measured). Wikipedia
biographies (Turing, Curie, Hopper) behave as L ≈ 1: each atomic fact is independently
checkable against the source. CNN/DailyMail summaries are mixed, with a holistic tail
— aggregate or global claims ("six patients", causal summaries) require reading almost
everything to refute, so L ≈ m and G_x → 0. These extremes are judgments, not
measurements, because no automatic LLM judge was run in the loop (see limitations).
Verdict. Neither revolution nor mere relabeling. The third (verification) coordinate
is real for natural language in the decomposable class — which covers much of useful
factual and multi-hop NL — where G_x grows. It collapses only for the holistic class,
which genuinely exists and is itself a publishable impossibility result: a class of
claims provably not locally verifiable. The contribution is not "we invented cheap
verification" (it exists). It is "we made L = d_min a measurable quantity that predicts
when randomized verification beats deterministic verification" — with one hard data point
(HotpotQA, L = 2.47) placing factual NL in the favorable regime. That was not obvious.
This does not revolutionize AI; it is a narrow real result plus a direction aligned with
test-time compute and hallucination detection.
Limitations (stated prominently).
- Incomputability.
C^t,Φ, and instance difficulty are incomputable. Everything reported is a proxy (compressor / reference-model log-loss); the "intrinsic floor" is a geometry relative to the chosen compressor, not an absolute numeric threshold. The invariance constantcis asymptotic and may be large in practice. - No automatic judge in the loop. The environment had no script-accessible LLM, so no
judge model was run.
Lfor biographies and summaries are small-N in-context judgments; only HotpotQA (300 items, derived fromsupporting_facts) is hard data. We did not inject errors and measure the true detectionq*with an automatic judge; the rigorous next step is exactly that, on a labeled faithfulness dataset (e.g. FActScore). - Conjectural optimality. Only the lower-bound direction of the conservation laws is argued. The 1-for-1 exchange (Theorem II) and achievability are open.
- Independence assumption. The simulator assumes errors are independent and claims are
cleanly decomposed. In real NL, shared latent premises can correlate claims and raise
the effective
L. Prevalence of the holistic tail in real corpora is not quantified. - Citations. Some 2025–2026 references need manual verification; only the pre-2025 foundations are cited with confidence.
All experiments run with no dependencies (stdlib Python 3 only):
python3 esperimento/run.py --backend mock --task both --samples 8
python3 esperimento/semantic_pcp.py
python3 esperimento/phase3_real.py
esperimento/triedro.py— measures(B, D, V, V_det, G_x), time-boundedC^tproxy via compression, Freivalds attestation, and theH_advestimator with semantic (bidirectional-entailment) clustering.esperimento/backends.py— pluggable backends (mock/ollama/openai-compat), so the same harness runs against a real model when one is available.esperimento/run.py— runs the four falsifiable checks on a real or mock model.esperimento/semantic_pcp.py— synthetic Phase 3 confirmingq* ~ m^(1 - 1/L).esperimento/phase3_real.py,real_data.json,hotpot_L.json— Phase 3 on downloaded real data (HotpotQALdistribution, Wikipedia, CNN/DailyMail).esperimento/README.md— the detailed experimental protocol.
The mock backend makes every number deterministic and machine-independent; the same
scripts accept a real model by changing --backend. Italian deep-dive documents in the
repository root (Intelligenza-Proporzionale.md, Analisi-Critica-Intelligenza- Proporzionale.md, Soluzione-Rivoluzionaria.md, RISULTATO-Fase3.md) contain the full
derivations, the red-team, and the prior-art audit behind this condensed paper.