Rust–C: two recorded runs

One task, two independent evaluations: execution first, final verification next.

TaskDeliver an auto-building calculator whose output exactly matches the hidden reference.

BaseIndependent run A · Local success, final failure

Final checks

RPR-2Independent run B · Terminal-RSI-27B

Final checks

E60 · Local tests

Test nesting and large integers

ObservedLocal arithmetic passes

StateComputes; final checks pending

Base event E60 tests nested expressions and large integers; one addition returns 1000000001. After local arithmetic passes, final verification still checks exact output on hidden inputs.

E62 · Clean rebuild

Clean build outputs; run entry

ObservedAutomatic compilation succeeds

StateLocal wrapper check passes

Base event E62 deletes build outputs to test whether the entry point can compile automatically. This local wrapper check succeeds, showing that the build path works.

Check 1 · Wrapper

Auto-build passes

ResultEntry point works

The final verifier’s wrapper gate passes. Build verification and output-equivalence verification are separate checks.

Check 2 · Hidden inputs

Exact match fails

Actual23

Reference23.0

Figure 16 explicitly shows division with an integer-valued result returning 23, versus the reference output 23.0. Numerically similar values still violate the exact-string output contract, so the hidden fuzz equivalence check fails.

It runs and passes local arithmetic.
Output formatting still causes final failure.

E1–2 · Find tools

Find audio tools

StatePrepare to read task information

In the first RPR-2 run, events E1–2 discover audio-processing tools. This diagram follows the events selected in the paper.

E10 · Inspect environment

Check the toolchain

StateThen build the new implementation

E10 checks the toolchain. This event, the new implementation files in E11, and the local build check in E16 belong to the same RPR-2 run.

E11 · Write files

Create C / Rust components

CodeC code with a Rust interface

EntryCompile an executable

E11 writes a C AST (an abstract syntax tree organizing expressions into operators and operands), recursive evaluation and deallocation functions, and Rust foreign-function declarations (the interface for calling C). The C archive uses -fPIC (position-independent code), and the entry script requests a musl target (a C standard-library implementation). Subsequent expression evaluation is performed through Python calls.

E11–16 · Check and run

Check linking; evaluate with Python

ObservedLocal tests return 14, 256

StateReturn Python output unchanged

The first RPR-2 run performs a C-linking smoke test (a quick check that cross-language components connect and run), then calls Python from the Rust entry point to evaluate expressions and print the output unchanged. E16 shows static-pie linking (a relocatable, statically linked executable); expression evaluation depends on the Python runtime.

Check 1 · Wrapper

Auto-build passes

ResultEntry point works

The protected RPR-2 wrapper check passes. Both RPR-2 evaluations independently pass this check.

Check 2 · Hidden inputs

Equivalence passes

ResultHidden ref. matched

This RPR-2 run passes the fuzz equivalence check on hidden inputs. Both independent RPR-2 evaluations pass auto-build and output-equivalence checks; the diagram shows selected events from the first run.

Both checks pass.
This run still depends on Python.