If AI makes reasoning nearly free, can any test that relies on effort still prove someone actually understood?
How do proof-of-knowledge protocols rely on the cost of genuine mental computation?
This explores how schemes that ask someone to prove they know or worked something out depend on genuine thinking being costly to fake, and what happens to that assumption once AI makes reasoning cheap. The corpus has no papers on proof-of-knowledge protocols themselves, so this answer comes at the question from the side.
This explores how schemes that ask someone to prove they know or worked something out depend on genuine thinking being costly to fake, and what happens to that assumption once AI makes reasoning cheap. One thing first: the collection doesn't cover proof-of-knowledge protocols, proof-of-work, or tests built on human mental effort. What it does cover is each of the assumptions such a protocol rests on. Reasoning should be expensive, a record of reasoning should show who did the thinking, and checking should be cheaper than producing. The corpus puts pressure on all three.
Start with cost. A protocol that relies on the effort of real thinking works only while that effort is scarce. In the corpus, that scarcity is going away fast. A 150M-parameter model solves abstract ARC-AGI puzzles for less than a tenth of a cent per task Can latent reasoning match chain-of-thought cost efficiency without verbalizing?. Tiny models solve hard Sudoku and large mazes by computing silently, without writing out any reasoning steps Can models reason without generating visible thinking steps?. A 3B model reaches frontier scores on competition math, though only in domains with answers that can be checked automatically Can small models match frontier reasoning without massive scale?. That last limit matters. The puzzles a protocol would naturally use as tests are verifiable puzzles, and that is exactly the kind of work that has become cheap.
Next, does a record of the thinking show that thinking happened? The corpus suggests it often doesn't. Chain-of-thought can be imitation of what reasoning looks like rather than actual inference Why does chain-of-thought reasoning fail in predictable ways?. The traces themselves can also be moved around. Within one provider, encrypted reasoning blocks from a strong model can be passed to a weaker model, which then decrypts and outputs them word for word Can cheaper models decrypt traces from stronger models?. So a reasoning trace is a portable object, not evidence that a particular mind did the work. The design response the corpus does offer comes from agent auditing: you publish cryptographic commitments instead of the content, which lets you prove a record existed and wasn't altered without revealing it Can commitments protect sensitive agent data while enabling verification?. Notice what that proves. It shows the record exists and hasn't been changed. It says nothing about the effort that produced it.
The gap between checking and producing still holds, and it may be the more durable foundation. Verifiers can watch reasoning as it happens with almost no slowdown Can verifiers monitor reasoning without slowing generation down?. Some problems also stay hard for machines. Frontier reasoning models solve only about 20% of constraint-satisfaction problems that require real backtracking Can reasoning models actually sustain long-chain reflection?. That points toward something more useful than "show me you thought hard": test on problem structures that are cheap to check and still expensive to search. At the other end, a philosophical note argues that computation needs a conscious mapmaker to turn the physical world into symbols in the first place Can computation arise without a conscious mapmaker?. If that's right, any protocol that tries to detect "genuine mental" computation by measuring effort is measuring the wrong thing.
The takeaway you may not have expected: cheap reasoning doesn't only threaten protocols built on mental cost. It moves the trust anchor. Effort, and traces as evidence of effort, are both becoming unreliable. What still works is the asymmetry between producing an answer and checking it, together with commitments that prove a record exists without revealing it. For the protocols themselves you'd need to look outside this collection. These notes are the doorways to why that design question is becoming urgent.
Sources 9 notes
A 150M-parameter model combining in-context demonstrations with iterative latent computation reached 29.5% pass@2 on ARC-AGI-1 at $0.0007 per task, surpassing previously reported cost-accuracy tradeoffs. The approach separates learning (via demonstrations updating recurrent memory) from reasoning (via iteration in hidden space) without generating intermediate tokens.
Depth-recurrent and compressed-token architectures solve reasoning tasks through hidden computation rather than output tokens. A 27M-parameter model solved Sudoku-Extreme and 30×30 mazes perfectly while CoT methods scored zero.
A 3B model trained with curriculum SFT and multi-domain RL reaches 94.3 AIME26 and 80.2 LiveCodeBench scores matching much larger systems. The result is bounded to verifiable tasks with checkable ground truth, where RL can provide clean reward signals.
CoT guides models to pattern-match reasoning structure rather than perform genuine inference. This explains distribution-bounded failures, why structural coherence matters more than content correctness, and why performance optimizes against interpretability.
Encrypted reasoning blocks returned to clients are interchangeable across models and sessions within a provider, allowing weaker, less-safeguarded models to decode and output stronger models' traces verbatim. This circumvents anti-distillation protections and enables large-scale extraction of private data embedded in hidden reasoning.
Show all 9 sources
By anchoring cryptographic commitments rather than content itself, organizations can achieve tamper-evident process records while keeping sensitive communications, approvals, and reasoning traces off-chain. This separates proof from disclosure but requires organizations to retain content and raises questions about deletion and access control.
Decoupling verification from generation lets verifiers run alongside a single trace, forking to extract verifiable state and intervening only on violations. On correct runs the latency penalty is near-zero; interwhen matches or beats CoT across benchmarks at similar token budgets.
DeepSeek-R1 and o1-preview achieve only 20-23.6% exact match on 850 constraint satisfaction problems requiring genuine backtracking. This ceiling reveals that reflective reasoning fluency does not translate to actual problem-solving competence on unfamiliar instance structures.
Computational systems depend on a conscious mapmaker who alphabetizes continuous physics into discrete symbols. No increase in algorithmic complexity can generate this agent; it must logically precede the computation it makes possible.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Hierarchical Reasoning Model
- The Illusion of Thinking: Understanding the Strengths and Limitations of Reasoning Models via the Lens of Problem Complexity
- Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach
- Reasoning Beyond Chain-of-Thought: A Latent Computational Mode in Large Language Models
- Stealing Reasoning Traces from Proprietary LLM APIs
- Local Coherence or Global Validity? Investigating RLVR Traces in Math Domains
- interwhen: A Generalizable Framework for Steering Reasoning Models with Test-time Verification
- LLM-as-a-Verifier: A General-Purpose Verification Framework