open-standards/proof
Repository files (latest commit first)
Filename Latest commit message Latest commit date
David Charlot 28c48b46e2
Some checks failed
wai cross-architecture byte-equality / windows-x86_64 (pull_request) Successful in 30s
wai cross-architecture byte-equality / linux-aarch64 (pull_request) Successful in 42s
joule-code conformance gate / Build + round-trip C1-C4 vectors (pull_request) Failing after 1m3s
WAI conformance / cargo-class corpora · linux-arm64 (pull_request) Successful in 1m1s
WAI conformance / cargo-class corpora · windows (pull_request) Successful in 1m21s
jouleclaw public surface must stay documented / Public-surface audit (jouleclaw-rs) (pull_request) Successful in 58s
WAI conformance / cross-arch byte-equality · linux-arm64 (pull_request) Successful in 20s
WAI conformance / cross-arch byte-equality · windows (pull_request) Successful in 22s
wai cross-architecture byte-equality / linux-x86_64 (pull_request) Successful in 14s
WAI conformance / cargo-class corpora · linux (pull_request) Successful in 29s
WAI conformance / cross-arch byte-equality · linux (pull_request) Successful in 15s
wai cross-architecture byte-equality / macos-arm64 (reference) (pull_request) Successful in 55s
WAI neural decoders end-to-end / synthetic fixtures → Rust decode → reference (±4) (pull_request) Failing after 1m5s
WAI conformance / cargo-class corpora · macos (pull_request) Successful in 13m25s
WAI conformance / cross-arch byte-equality · macos (pull_request) Successful in 3m42s
chore: Rust 1.98.0 (latest stable) + refresh every dependency
Toolchain 1.97.1 -> 1.98.0 (released 2026-08-18) in both `rust-toolchain.toml`
files, 33 pins across 5 CI workflows, and 26 workspace `rust-version`
declarations. Nothing pinned to 1.97 remains.

Dependencies refreshed in all 25 workspaces: 1,751 changes, every one
semver-compatible. The vendored `jouledesk-rs/vendor/libwebrtc` tree is
deliberately excluded — it is a patched vendor drop, not a managed dependency.

Note the `1.97` in `jouleclaw-loader-gguf/BENCHMARKS.md` is a benchmark timing
("1.97 ms"), not a version; a blind find-and-replace would have corrupted a
results table, so pins were matched by field rather than by string.

Also completes a cross-workspace regression this repo has been carrying. When
`budget_funds` and `caveats` were added to `jcp_schema::Grant`, the workspaces
that path-depend on `jcp-schema` were fixed one wave at a time, and three were
missed: `joule-ui`, `jouleclaw` and `mesh` still built `Grant` without the new
fields and had been failing to compile since. `cargo test --workspace` inside
`jcp-rs` never builds them, which is exactly why it went unseen; checking every
workspace independently is what surfaced it. Two of the six sites used field-init
shorthand (`budget_uj,` with no colon), so they needed a separate pass — a
reminder that a regex over initializers is not a substitute for compiling.

Verified: 21 of 25 workspaces `cargo check --workspace --all-targets` clean.

Not fixed here, and NOT caused by this change — each verified against the
pristine tree rather than assumed:

- `eoc/eoc-rs`: `RequestBuilder::query` is unavailable because reqwest is taken
  with `default-features = false`, which drops the feature providing it.
  reqwest is 0.13.4 before and after, and `serde_urlencoded` is absent from the
  lock in both, so this predates the refresh. Fixing it is a choice between
  enabling the feature and changing the call sites.
- `openpay`: `Hmac::new_from_slice` unresolved. hmac 0.12.1, digest 0.10.7 and
  sha2 0.10.9 are identical before and after — same versions in, same result.
- `smart-byte/smart-byte-rs`: never resolved on main. Its manifest asked for two
  features that do not exist (`rand_core`'s `alloc`, which no version has ever
  had, and `cbc`'s `std`, where 0.2 offers `alloc`); both are corrected here,
  which advances it from "will not resolve" to "will not compile" and exposes
  the real problem — the manifest wants `rand = "0.10"` while the lock pinned
  `rand 0.8.8` and 38 files still use the 0.8-era API (`thread_rng`,
  `rand::rngs::OsRng`). That is a two-major-version source migration and wants
  its own change, not a side effect of a toolchain bump.

`wai/wai-rs` needs libjxl present to build its default feature set; CI installs
`libjxl-dev`, so this is a local environment gap rather than a repo failure.
2026-08-26 07:58:37 -04:00
..
conformance/v1 Add the proof open standard — a carrier for verified work 2026-06-07 15:30:07 -04:00
proof-rs chore: Rust 1.98.0 (latest stable) + refresh every dependency 2026-08-26 07:58:37 -04:00
CONTRIBUTING.md Add the proof open standard — a carrier for verified work 2026-06-07 15:30:07 -04:00
LICENSE Add the proof open standard — a carrier for verified work 2026-06-07 15:30:07 -04:00
LICENSE-SPEC Add the proof open standard — a carrier for verified work 2026-06-07 15:30:07 -04:00
README.md proof: a real hardware energy meter (the HwShunt backend) 2026-06-18 15:24:58 -04:00
SPEC.md Add the proof open standard — a carrier for verified work 2026-06-07 15:30:07 -04:00

proof — A Carrier for Verified Work

The verification cargo class of the substrate. A proof obligation is content-addressed; a solver is anything that can attempt one at a declared tier; a discharged obligation seals as a signed JCR-1 receipt that records which tier closed it and the joules it cost. The standard fixes the one axis the theorem-proving field leaves implicit — joules per verified proof — and makes it portable: any prover can emit a Proof receipt, and any auditor can verify it with the same tooling as a Map, Sandbox, or Joule Code receipt.

The cheapest sufficient solver wins. Every obligation goes to the cheapest rung that can discharge it — deterministic automation (T0), then SMT (T1), then a small distilled prover (T2), then a frontier model (T3, last resort) — and escalates only on failure. Correctness is never traded for energy: a solver returns proved only when a verifier would accept the artifact, so the standard changes which tier pays for a proof, not whether it is checked. The joules spent on a cheaper solver that ran and failed first are disclosed as the cost of escalation, never hidden. Energy carries an honest provenance tag (HwShunt / ModelBased / Estimator), and a receipt for an Ungrounded statement says, in the signed artifact, that the statement was never validated against intent — a proof is not a specification.

  • Site: jouleproof.transaction.science (the JouleProof pillar is the steward + services layer over this standard).
  • Licence: Apache-2.0 for reference code (see LICENSE); CC-BY-4.0 for specification text (see LICENSE-SPEC).
  • Status: v0.1.0 draft. Specification core published (SPEC.md); reference workspace proof-rs/.

What's here

proof/
├── SPEC.md            — the normative standard (§1–§9)
├── conformance/v1/    — published vectors (receipt wire + signed core + envelope)
└── proof-rs/          — the Apache-2.0 reference implementation

The reference implementation (proof-rs/)

  • proof-schema — the content-addressed goal (blake3(statement‖0x00‖context)), the cheapest-first tier ladder, the honest energy model (HwShunt/ModelBased/Estimator with the coupling enforced), SpecGrounding, the verdict, and the Solver trait every backend implements. Canonical det-CBOR content addressing.
  • proof-solvers — two real rungs with measured energy: a propositional decider (T0) that parses a boolean goal and decides validity by truth-table in process, and z3 (T1) — shell or kept resident across goals — that decides an SMT-LIB goal (assert the negation; unsat ⇒ valid). Each refuses rather than fakes, so the router escalates. The model rungs (T2/T3) are honest stand-ins behind the same trait.
  • proof-cascade — the escalation router (every joule accounted, wasted_uj disclosed), the content-addressed proof cache (the energy flywheel, durable as line-delimited JSON), batch energy accounting against a frontier-only baseline with the per-tier Amdahl breakdown, and a real hardware energy meter (meter — the HwShunt backend): it brackets a real proof, run on every core, against an idle baseline using the platform's energy interface (IOReport via macmon on Apple Silicon, RAPL on Linux) and returns measured microjoules, so the headline joules per verified proof can be a real reading, not only a model. Returns nothing where no interface is reachable — the caller keeps the honestly-tagged ModelBased figure rather than inventing one.
  • proof-receipt — the proof/1 JCR-1 receipt: canonical det-CBOR + COSE_Sign1/EdDSA, vendored byte-compatible with the family's cross-language verifiers; refuses to seal an unproved goal.
  • proof-conformance — C1–C5 + a negative pack, all checks real, published vectors in conformance/v1/.
  • proof-cli — the proof reference demo: a proof workload reporting joules-per-proof against a frontier-only baseline, the Amdahl breakdown, the cache flywheel, and a sealed + verified receipt. proof --measure adds a real hardware reading of a non-trivial T0 proof (HwShunt, where an energy interface is present).

cargo test --workspace green; cargo clippy --workspace --all-targets warning-free. The two bottom rungs decide for real with measured energy; the model rungs are honestly marked as stand-ins until inference backends are wired.

Honesty the standard records

  • A proof is not a specification. spec_grounding rides in the signed receipt; Ungrounded is the default and a prover may never self-certify it.
  • The multiple shrinks with difficulty. The accounting reports energy per closing tier, so the few hardest goals dominating the joules (Amdahl) is visible, not averaged away.
  • Energy is reported at all — per proof, with an honest provenance tag — which the field otherwise leaves to be inferred from device-days.