A recursive verifier must fit inside a successor proof of the same authenticated class. This study states the fixed-point acceptance test, closes a two-link chain in a 2^23-position class, records two implementation probes and separates recursion mechanics from application-level block semantics.
The fixed-point test
Embedding a verifier in a proof does not by itself establish recursion. The successor relation must host a verifier for the same authenticated class and expose the same public layout again. Otherwise the circuit grows at every step or terminates in a native decision that cannot be continued.
Here a relation is the computation enforced by the proof constraints. A proof class fixes that relation's constraint matrix, public input/output layout and proof parameters. Recursion reaches a fixed point only when one instance of a class can verify a proof from the same class without changing any of those objects.
The experiment used a direct acceptance criterion:
Both links had to use the same class, matrix identity and public input/output shape. The smallest measured class that closed under this test used a constraint domain with 223 field positions. This is a capacity result, not a security parameter.
Replaying BaseFold inside the relation
BaseFold is the polynomial-commitment and opening system used by the recursive proof. Its native verifier consumes commitments, round messages, transcript challenges, query openings and Merkle authentication. The recursive relation reproduced each step in FieldR1cs—the binary-field constraint representation used to express native verifier operations inside a proof—instead of accepting a host-computed boolean.
- verifier arithmetic is expressed over GF(2128);
- the transcript trace absorbs the same messages and derives the same challenges;
- public I/O binds predecessor and successor claims across adjacent links;
- the matrix digest identifies the exact verifier class being replayed.
A verifier-shaped computation with a different byte order, padding rule or challenge schedule is a different protocol. Recursive acceptance must bind the same proof bytes and statement accepted natively.
Separate recursion mechanics from block semantics
The fixed-point experiment intentionally used a minimal link relation. It answered one question: can this verifier class verify itself indefinitely? Header rules, transaction roots, authorization and exact UTXO transition were outside that test and were composed only after the class boundary closed.
This separation makes every result attributable to one boundary. Recursive closure can be evaluated without conflating it with block semantics, and application rules can be composed without silently changing the recursion class.
Two implementation probes
Closing the class also established implementation costs and transcript-boundary requirements that a native verifier benchmark would not show:
| Probe | Observed result | Interpretation |
|---|---|---|
| Class-statement digest reuse | 224-position class: 206 s → 36 s | A class-fixed digest was being reconstructed as repeated witness work |
| Variable-length transcript finalization | A boundary mutation distinguished partial absorption from complete finalization | Partial rate blocks require explicit padding and finalization |
The first result is a performance optimization with unchanged statement semantics. The second is an adversarial acceptance test that fixes the required transcript rule: recursive security includes every byte schedule at the digest boundary, not only the outer proof equation.
Accepted invariants
- A link verifies a predecessor of the same authenticated class.
- The base case establishes the initial claim without bypassing class identity.
- Adjacent links agree on exact public start and end claims.
- Transcript challenges are derived inside the verified trace.
- The native terminal checks the same relation replayed recursively.
Result
A 223 class closed under repeated verifier application. Once that fixed shape existed, block semantics could be added and optimized without making proof size or verifier geometry grow with chain age. The resulting design condition is general: establish the recursive fixed point before attaching the application's largest relation.