fix(aiur): replay constrained calls cached as hints by arthurpaulino · Pull Request #570 · argumentcomputer/ix

arthurpaulino · 2026-08-19T02:11:24Z

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel.

Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs.

Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully.

Validation:

lake exe ix codegen
cargo clippy --release
cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture
lake test -- aiur-prove
lake test -- --ignored ixvm
exact Nat.add_comm benchmark prove/verify path

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel. Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs. Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully. Validation: - lake exe ix codegen - cargo clippy --release - cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture - lake test -- aiur-prove - lake test -- --ignored ixvm - exact Nat.add_comm benchmark prove/verify path

…itter Main's #570 taught the emitter to promote zero-multiplicity hint entries at call and return sites instead of blind-inserting; the recursive-verifier toplevel is generated on this branch, so its runner re-emits under the new pattern. The kernel runner (aiur_ixvm.rs) stays byte-identical to main's — this branch's changes don't alter its emission.

arthurpaulino · 2026-08-19T02:11:24Z

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel.

Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs.

Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully.

Validation:

lake exe ix codegen
cargo clippy --release
cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture
lake test -- aiur-prove
lake test -- --ignored ixvm
exact Nat.add_comm benchmark prove/verify path

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel. Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs. Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully. Validation: - lake exe ix codegen - cargo clippy --release - cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture - lake test -- aiur-prove - lake test -- --ignored ixvm - exact Nat.add_comm benchmark prove/verify path

…itter Main's #570 taught the emitter to promote zero-multiplicity hint entries at call and return sites instead of blind-inserting; the recursive-verifier toplevel is generated on this branch, so its runner re-emits under the new pattern. The kernel runner (aiur_ixvm.rs) stays byte-identical to main's — this branch's changes don't alter its emission.

arthurpaulino · 2026-08-19T02:11:24Z

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel.

Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs.

Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully.

Validation:

lake exe ix codegen
cargo clippy --release
cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture
lake test -- aiur-prove
lake test -- --ignored ixvm
exact Nat.add_comm benchmark prove/verify path

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel. Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs. Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully. Validation: - lake exe ix codegen - cargo clippy --release - cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture - lake test -- aiur-prove - lake test -- --ignored ixvm - exact Nat.add_comm benchmark prove/verify path

…itter Main's #570 taught the emitter to promote zero-multiplicity hint entries at call and return sites instead of blind-inserting; the recursive-verifier toplevel is generated on this branch, so its runner re-emits under the new pattern. The kernel runner (aiur_ixvm.rs) stays byte-identical to main's — this branch's changes don't alter its emission.

arthurpaulino · 2026-08-19T02:11:24Z

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel.

Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs.

Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully.

Validation:

lake exe ix codegen
cargo clippy --release
cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture
lake test -- aiur-prove
lake test -- --ignored ixvm
exact Nat.add_comm benchmark prove/verify path

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel. Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs. Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully. Validation: - lake exe ix codegen - cargo clippy --release - cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture - lake test -- aiur-prove - lake test -- --ignored ixvm - exact Nat.add_comm benchmark prove/verify path

…itter Main's #570 taught the emitter to promote zero-multiplicity hint entries at call and return sites instead of blind-inserting; the recursive-verifier toplevel is generated on this branch, so its runner re-emits under the new pattern. The kernel runner (aiur_ixvm.rs) stays byte-identical to main's — this branch's changes don't alter its emission.

arthurpaulino · 2026-08-19T02:11:24Z

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel.

Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs.

Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully.

Validation:

lake exe ix codegen
cargo clippy --release
cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture
lake test -- aiur-prove
lake test -- --ignored ixvm
exact Nat.add_comm benchmark prove/verify path

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel. Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs. Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully. Validation: - lake exe ix codegen - cargo clippy --release - cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture - lake test -- aiur-prove - lake test -- --ignored ixvm - exact Nat.add_comm benchmark prove/verify path

…itter Main's #570 taught the emitter to promote zero-multiplicity hint entries at call and return sites instead of blind-inserting; the recursive-verifier toplevel is generated on this branch, so its runner re-emits under the new pattern. The kernel runner (aiur_ixvm.rs) stays byte-identical to main's — this branch's changes don't alter its emission.

arthurpaulino · 2026-08-19T02:11:24Z

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel.

Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs.

Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully.

Validation:

lake exe ix codegen
cargo clippy --release
cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture
lake test -- aiur-prove
lake test -- --ignored ixvm
exact Nat.add_comm benchmark prove/verify path

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel. Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs. Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully. Validation: - lake exe ix codegen - cargo clippy --release - cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture - lake test -- aiur-prove - lake test -- --ignored ixvm - exact Nat.add_comm benchmark prove/verify path

…itter Main's #570 taught the emitter to promote zero-multiplicity hint entries at call and return sites instead of blind-inserting; the recursive-verifier toplevel is generated on this branch, so its runner re-emits under the new pattern. The kernel runner (aiur_ixvm.rs) stays byte-identical to main's — this branch's changes don't alter its emission.

arthurpaulino · 2026-08-19T02:11:24Z

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel.

Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs.

Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully.

Validation:

lake exe ix codegen
cargo clippy --release
cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture
lake test -- aiur-prove
lake test -- --ignored ixvm
exact Nat.add_comm benchmark prove/verify path

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel. Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs. Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully. Validation: - lake exe ix codegen - cargo clippy --release - cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture - lake test -- aiur-prove - lake test -- --ignored ixvm - exact Nat.add_comm benchmark prove/verify path

…itter Main's #570 taught the emitter to promote zero-multiplicity hint entries at call and return sites instead of blind-inserting; the recursive-verifier toplevel is generated on this branch, so its runner re-emits under the new pattern. The kernel runner (aiur_ixvm.rs) stays byte-identical to main's — this branch's changes don't alter its emission.

arthurpaulino · 2026-08-19T02:11:24Z

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel.

Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs.

Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully.

Validation:

lake exe ix codegen
cargo clippy --release
cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture
lake test -- aiur-prove
lake test -- --ignored ixvm
exact Nat.add_comm benchmark prove/verify path

Unconstrained calls cache function queries with zero multiplicity. When a later constrained call reused the same query, the executors previously incremented only the cached callee row. They did not replay its body, so nested function, memory, and gadget lookup obligations could remain inactive. The resulting witness had unbalanced lookup channels and failed verification with UnbalancedChannel. Treat a constrained cache hit with zero multiplicity as promotion: replay the callee body in constrained mode so activation recursively reaches its dependency tree. At return, reuse the existing query, assert that the recomputed output agrees with the cached hint, and increment its multiplicity instead of inserting a duplicate. Apply the same behavior to the bytecode executor and generated Rust executor, then regenerate both codegen outputs. Add a focused Rust prove/verify regression and an aiur-prove case where an unconstrained call is followed by an identical constrained call whose callee performs a nested call. With the fix removed, both reproduce UnbalancedChannel; with the fix restored, they verify successfully. Validation: - lake exe ix codegen - cargo clippy --release - cargo test -p aiur --release prove_verify_promotes_nested_unconstrained_call -- --nocapture - lake test -- aiur-prove - lake test -- --ignored ixvm - exact Nat.add_comm benchmark prove/verify path

…itter Main's #570 taught the emitter to promote zero-multiplicity hint entries at call and return sites instead of blind-inserting; the recursive-verifier toplevel is generated on this branch, so its runner re-emits under the new pattern. The kernel runner (aiur_ixvm.rs) stays byte-identical to main's — this branch's changes don't alter its emission.

arthurpaulino force-pushed the ap/aiur-hint-cache-fix branch from 0e94e50 to 529b134Compare August 19, 2026 09:58

arthurpaulino enabled auto-merge (squash) August 19, 2026 09:58

arthurpaulino force-pushed the ap/aiur-hint-cache-fix branch 2 times, most recently from 61e9960 to 77020a7Compare August 19, 2026 12:52

arthurpaulino force-pushed the ap/aiur-hint-cache-fix branch from 77020a7 to 9755debCompare August 19, 2026 19:25

gabriel-barrett approved these changes Aug 19, 2026
View reviewed changes

arthurpaulino merged commit dffb3f4 into mainAug 19, 2026
11 checks passed

arthurpaulino deleted the ap/aiur-hint-cache-fix branch August 19, 2026 19:46