feat: Add SP1 and Zisk kernel proving backends

[samuelburnham]

This pull request adds RISC-V zkVM proving backends for the Rust kernel — Zisk as the primary target (single process, single GPU), SP1 as an experimental alternative — together with the host pipeline that makes whole-environment Ix proving practical: RAM-aware sharding, tree aggregation with in-circuit assumption discharge, and cross-run proof reuse. Guest runs are validated by the shard's committed failures publics word; cycle counts are deterministic ziskemu step counts.

Key Results

• Whole-environment proving works end to end on a single GPU: profile → shard plan (.ixes manifest) → leaf proofs → tree-aligned aggregation to a single proof with no dangling assumptions
• Shard count is auto-sized from machine RAM and profiled heartbeats — no manual budget tuning
• Cross-run reuse: store-aware planning re-proves only novel shards; a shard whose certified targets are already covered by stored proofs is skipped entirely
• Guest checks an explicit check-list against a closure-injected sub-env (never the whole env); 112-byte shard publics bind the env hash, range/count, failures word, and assumption roots
• ByteArray.utf8DecodeChar?_utf8EncodeChar_append — the most expensive proof in Init — provable via the NatSuccMode::Stuck cache
• Init is provable in principle in 288 shards on a 256GB RAM machine, ~0.35 constants per second out of ~52k total constants = ~37-45 hours on a single GPU.

[samuelburnham]

This pull request adds RISC-V zkVM proving backends for the Rust kernel — Zisk as the primary target (single process, single GPU), SP1 as an experimental alternative — together with the host pipeline that makes whole-environment Ix proving practical: RAM-aware sharding, tree aggregation with in-circuit assumption discharge, and cross-run proof reuse. Guest runs are validated by the shard's committed failures publics word; cycle counts are deterministic ziskemu step counts.

Key Results

• Whole-environment proving works end to end on a single GPU: profile → shard plan (.ixes manifest) → leaf proofs → tree-aligned aggregation to a single proof with no dangling assumptions
• Shard count is auto-sized from machine RAM and profiled heartbeats — no manual budget tuning
• Cross-run reuse: store-aware planning re-proves only novel shards; a shard whose certified targets are already covered by stored proofs is skipped entirely
• Guest checks an explicit check-list against a closure-injected sub-env (never the whole env); 112-byte shard publics bind the env hash, range/count, failures word, and assumption roots
• ByteArray.utf8DecodeChar?_utf8EncodeChar_append — the most expensive proof in Init — provable via the NatSuccMode::Stuck cache
• Init is provable in principle in 288 shards on a 256GB RAM machine, ~0.35 constants per second out of ~52k total constants = ~37-45 hours on a single GPU.

[samuelburnham]

This pull request adds RISC-V zkVM proving backends for the Rust kernel — Zisk as the primary target (single process, single GPU), SP1 as an experimental alternative — together with the host pipeline that makes whole-environment Ix proving practical: RAM-aware sharding, tree aggregation with in-circuit assumption discharge, and cross-run proof reuse. Guest runs are validated by the shard's committed failures publics word; cycle counts are deterministic ziskemu step counts.

Key Results

• Whole-environment proving works end to end on a single GPU: profile → shard plan (.ixes manifest) → leaf proofs → tree-aligned aggregation to a single proof with no dangling assumptions
• Shard count is auto-sized from machine RAM and profiled heartbeats — no manual budget tuning
• Cross-run reuse: store-aware planning re-proves only novel shards; a shard whose certified targets are already covered by stored proofs is skipped entirely
• Guest checks an explicit check-list against a closure-injected sub-env (never the whole env); 112-byte shard publics bind the env hash, range/count, failures word, and assumption roots
• ByteArray.utf8DecodeChar?_utf8EncodeChar_append — the most expensive proof in Init — provable via the NatSuccMode::Stuck cache
• Init is provable in principle in 288 shards on a 256GB RAM machine, ~0.35 constants per second out of ~52k total constants = ~37-45 hours on a single GPU.

[samuelburnham]

This pull request adds RISC-V zkVM proving backends for the Rust kernel — Zisk as the primary target (single process, single GPU), SP1 as an experimental alternative — together with the host pipeline that makes whole-environment Ix proving practical: RAM-aware sharding, tree aggregation with in-circuit assumption discharge, and cross-run proof reuse. Guest runs are validated by the shard's committed failures publics word; cycle counts are deterministic ziskemu step counts.

Key Results

• Whole-environment proving works end to end on a single GPU: profile → shard plan (.ixes manifest) → leaf proofs → tree-aligned aggregation to a single proof with no dangling assumptions
• Shard count is auto-sized from machine RAM and profiled heartbeats — no manual budget tuning
• Cross-run reuse: store-aware planning re-proves only novel shards; a shard whose certified targets are already covered by stored proofs is skipped entirely
• Guest checks an explicit check-list against a closure-injected sub-env (never the whole env); 112-byte shard publics bind the env hash, range/count, failures word, and assumption roots
• ByteArray.utf8DecodeChar?_utf8EncodeChar_append — the most expensive proof in Init — provable via the NatSuccMode::Stuck cache
• Init is provable in principle in 288 shards on a 256GB RAM machine, ~0.35 constants per second out of ~52k total constants = ~37-45 hours on a single GPU.

[samuelburnham]

This pull request adds RISC-V zkVM proving backends for the Rust kernel — Zisk as the primary target (single process, single GPU), SP1 as an experimental alternative — together with the host pipeline that makes whole-environment Ix proving practical: RAM-aware sharding, tree aggregation with in-circuit assumption discharge, and cross-run proof reuse. Guest runs are validated by the shard's committed failures publics word; cycle counts are deterministic ziskemu step counts.

Key Results

• Whole-environment proving works end to end on a single GPU: profile → shard plan (.ixes manifest) → leaf proofs → tree-aligned aggregation to a single proof with no dangling assumptions
• Shard count is auto-sized from machine RAM and profiled heartbeats — no manual budget tuning
• Cross-run reuse: store-aware planning re-proves only novel shards; a shard whose certified targets are already covered by stored proofs is skipped entirely
• Guest checks an explicit check-list against a closure-injected sub-env (never the whole env); 112-byte shard publics bind the env hash, range/count, failures word, and assumption roots
• ByteArray.utf8DecodeChar?_utf8EncodeChar_append — the most expensive proof in Init — provable via the NatSuccMode::Stuck cache
• Init is provable in principle in 288 shards on a 256GB RAM machine, ~0.35 constants per second out of ~52k total constants = ~37-45 hours on a single GPU.

[samuelburnham]

This pull request adds RISC-V zkVM proving backends for the Rust kernel — Zisk as the primary target (single process, single GPU), SP1 as an experimental alternative — together with the host pipeline that makes whole-environment Ix proving practical: RAM-aware sharding, tree aggregation with in-circuit assumption discharge, and cross-run proof reuse. Guest runs are validated by the shard's committed failures publics word; cycle counts are deterministic ziskemu step counts.

Key Results

• Whole-environment proving works end to end on a single GPU: profile → shard plan (.ixes manifest) → leaf proofs → tree-aligned aggregation to a single proof with no dangling assumptions
• Shard count is auto-sized from machine RAM and profiled heartbeats — no manual budget tuning
• Cross-run reuse: store-aware planning re-proves only novel shards; a shard whose certified targets are already covered by stored proofs is skipped entirely
• Guest checks an explicit check-list against a closure-injected sub-env (never the whole env); 112-byte shard publics bind the env hash, range/count, failures word, and assumption roots
• ByteArray.utf8DecodeChar?_utf8EncodeChar_append — the most expensive proof in Init — provable via the NatSuccMode::Stuck cache
• Init is provable in principle in 288 shards on a 256GB RAM machine, ~0.35 constants per second out of ~52k total constants = ~37-45 hours on a single GPU.

[samuelburnham]

This pull request adds RISC-V zkVM proving backends for the Rust kernel — Zisk as the primary target (single process, single GPU), SP1 as an experimental alternative — together with the host pipeline that makes whole-environment Ix proving practical: RAM-aware sharding, tree aggregation with in-circuit assumption discharge, and cross-run proof reuse. Guest runs are validated by the shard's committed failures publics word; cycle counts are deterministic ziskemu step counts.

Key Results

• Whole-environment proving works end to end on a single GPU: profile → shard plan (.ixes manifest) → leaf proofs → tree-aligned aggregation to a single proof with no dangling assumptions
• Shard count is auto-sized from machine RAM and profiled heartbeats — no manual budget tuning
• Cross-run reuse: store-aware planning re-proves only novel shards; a shard whose certified targets are already covered by stored proofs is skipped entirely
• Guest checks an explicit check-list against a closure-injected sub-env (never the whole env); 112-byte shard publics bind the env hash, range/count, failures word, and assumption roots
• ByteArray.utf8DecodeChar?_utf8EncodeChar_append — the most expensive proof in Init — provable via the NatSuccMode::Stuck cache
• Init is provable in principle in 288 shards on a 256GB RAM machine, ~0.35 constants per second out of ~52k total constants = ~37-45 hours on a single GPU.

[samuelburnham]

This pull request adds RISC-V zkVM proving backends for the Rust kernel — Zisk as the primary target (single process, single GPU), SP1 as an experimental alternative — together with the host pipeline that makes whole-environment Ix proving practical: RAM-aware sharding, tree aggregation with in-circuit assumption discharge, and cross-run proof reuse. Guest runs are validated by the shard's committed failures publics word; cycle counts are deterministic ziskemu step counts.

Key Results

• Whole-environment proving works end to end on a single GPU: profile → shard plan (.ixes manifest) → leaf proofs → tree-aligned aggregation to a single proof with no dangling assumptions
• Shard count is auto-sized from machine RAM and profiled heartbeats — no manual budget tuning
• Cross-run reuse: store-aware planning re-proves only novel shards; a shard whose certified targets are already covered by stored proofs is skipped entirely
• Guest checks an explicit check-list against a closure-injected sub-env (never the whole env); 112-byte shard publics bind the env hash, range/count, failures word, and assumption roots
• ByteArray.utf8DecodeChar?_utf8EncodeChar_append — the most expensive proof in Init — provable via the NatSuccMode::Stuck cache
• Init is provable in principle in 288 shards on a 256GB RAM machine, ~0.35 constants per second out of ~52k total constants = ~37-45 hours on a single GPU.