Skip to content

v0.5 lane 2: closed performance claims by κ (frontier register, decider, factory obligation, UC-PERF-01 target) - #137

Merged
afflom merged 9 commits into
mainfrom
claude/project-thread-61bbfh
Nov 11, 2026
Merged

afflom merged 9 commits into
mainfrom
claude/project-thread-61bbfh

Conversation

@afflom

@afflom afflom commented Nov 11, 2026 •

Copy link
Copy Markdown
Member

Requested by Alex · project thread

Layer 2 of v0.5: "codec X codes corpus κ in exactly N bytes and S steps" is decided by running the client, and the factory records whether it is proved or refuted.

Stacking. This PR carries lane 1's vocabulary commits (uorc::performance: step measure, corpus κ) and lane 3's portfolio-as-table commit (portfolio::Table, compress_stream_with) so that each definition exists once. It contains current main (#132, #136); its #136 conflict is resolved the way lane 3 resolved it, with the retrained weights in weights.rs. Merge order: lane 1 first, then this PR. v0.5 merges are on hold until v0.4.0 is tagged.

What it adds

  • crates/frontier (lib + bin). It depends on the shipped uorc library. It is not in xtask, because xtask must not read the client.
    • Register frontier.toml: corpora, pinned comparators, encoder points and claims. Every κ recomputes (frontier check) and the file is written in canonical form.
    • Corpus κ is uorc::performance::corpus_kappa. Members are checked against their hashes, and a git:<rev> source is built offline from git objects.
    • Encoder point κ is SHA-256(uorc/encoder-point/1 ‖ export ‖ plan ‖ state ‖ lanes). The plan is a portfolio table (sha256 of the entries and of the weights) or one fixed strategy, coded as a one-entry table.
    • Claim forms are closed, bound, dominance, exclusion and universal (a point excluded on every corpus by a named kernel theorem and parameter, recorded with no corpus). id is the κ of the question. Status is minted, proved or refuted. receipt is local or factory:<identity>.
    • decide compresses each member as its own stream, takes decode steps from the frame headers (performance::frame_steps) and round-trips the stream. A claim the factory has already decided is never rerun. If a stated claim is not reproduced, it is refuted and the observed values are kept.
    • Bound and dominance claims are decided from the closed claims without coding anything. Lane 3's engine uses decide, decide_dominance, exclude, exclude_universal and excluded.
  • frontier.toml holds three corpora:
    • uorc-v0.3.0: 8 blobs from tag v0.3.0, 1.44 MB, offline.
    • Canterbury and Silesia, pinned by the member hashes in the v0.3.0 release bench.
    • Comparator sizes: Canterbury and Silesia from the v0.3.0 release run (7 tools), and the offline corpus measured with gzip, bzip2 and xz.
    • Decided locally for the shipped point at main's export on uorc-v0.3.0: 577,506 bytes, 214,329,464 steps. That is smaller than xz -9e at 595,432, bzip2 at 606,478 and gzip at 650,271. Before uorc v0.4: choice rule tests x86 before size, keeps the v0.3 entry in small schedules #136 the same corpus was 577,331 bytes and 211,930,176 steps.
  • Factory obligation frontier (hermetic; needs native-x86_64): a release job fetches the corpora, decides every corpus with --by factory:<identity> and uploads factory-frontier. Only the decide step's outcome is recorded, so a failed download records nothing. publish needs it, puts frontier.md at the top of the release notes and ships uorc-vX-frontier.toml as an asset. It adds no PR-time leg. The formal and xtask sets exclude crates/frontier/ and frontier.toml (manifest only), so the formal legs do not rerun on register changes.
  • UC-PERF-01 target. On every public corpus, the archive is no larger than each pinned comparator's. The row moves from measured_no_target to benchmark_target_unmet / measured_target_unmet, since at v0.3.0 Silesia was 41,726,363 bytes against 39,112,562 for zpaq -m5. The release's bound claims decide it per comparator. Updated across the model, the registry, Claims.lex.tex and the regenerated projections (check-model and audit-source-authority are clean).
  • uorc inspect --json reports steps for each frame.

Checks run locally

cargo test --release -p frontier (5 tests), cargo test --release -p uorc --lib (66), cargo clippy -p frontier --all-targets (clean), cargo test -p repo-model -p repo-conformance, xtask check-model, xtask audit-source-authority, node --test scripts/factory.test.mjs. I could not fetch Canterbury and Silesia here because the hosts are blocked from this container, so their closed claims are first decided by the release's frontier job.

🤖 Generated with Claude Code

https://claude.ai/code/session_013Asa3QshCSRwiddS64zU3j

A step is one model input evaluated for one coded bit, read from a frame
header alone. A codec point names basis, profile word, state and lanes.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3LszhHCxmceQ2V8xxx
…solidates

Uorc.Engine (src/Uorc/Engine.lex.tex) states the engine that moves the codec
through its space, with kernel-checked laws: exact rule 30 on a 64-cell ring
(stepFromBelowPow2, closed vectors), bounded Hebbian weights 1..16 (+2/-1),
the winner of a proved dominance is scheduled before the incumbent it beat,
dominance in bytes and steps is a strict partial order that never costs
bytes, a result known by its kappa is never rerun, and the generated
workflow's schedule and budgets are valid.

The portfolio becomes data in the byte form the model's compress reads
(5 bytes per strategy: u32 LE profile word with bit 31 = x86, state byte;
one weight per family and strategy). crates/uorc/src/weights.rs is the
shipped table, generated by the engine from model/engine.toml and seeded with
the v0.4 table. compress_stream_with codes under any table. The hand-run
learning (examples/portfolio_outcomes.rs, portfolio-outcomes.tsv) is
superseded by the engine.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3LeJgXkUvvAfeAGt9A
crates/frontier holds frontier.toml (corpora, pinned comparators, encoder
points, claims by the κ of their question) and decides closed claims by
running the shipped codec over a κ-named corpus: exact archive bytes and
decode steps (uorc::performance), round-tripped. Bound, dominance and
exclusion claims are decided from closed ones without coding. A claim the
factory decided is never rerun. inspect --json reports each frame's steps.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3QshCSRwiddS64zU3j
The register pins three κ-named corpora (uorc-v0.3.0 from git objects, and
Canterbury and Silesia by their published member hashes) and the comparator
sizes of the v0.3.0 release run. The release's new hermetic obligation
`frontier` (needs native-x86_64) decides the closed claims of the release's
codec point over all three and the bound claims against every comparator,
publishes frontier.md in the release notes and frontier.toml as an asset.

UC-PERF-01 gets a target: on every public corpus the archive is no larger
than each pinned comparator's. It stays open, measured_target_unmet, while a
bound is refuted (Silesia against zpaq -m5 at v0.3.0).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3QshCSRwiddS64zU3j
… on every corpus)

Form::Universal records a point excluded by a named theorem template and
parameter with no corpus, so its κ blocks the point everywhere without a
run; Register::excluded answers for exclusions and universal claims alike.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3QshCSRwiddS64zU3j
Takes lane 3's resolution of #136 against the portfolio table (its weights
reseeded in weights.rs) and main's factory sets with the frontier entries;
re-decides the offline corpus at main's export identity.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3QshCSRwiddS64zU3j
#140 moved the encoder to planned frames and coded strategies, so the
portfolio-as-table commit this branch carried for lane 3 leaves this PR
(lane 3 brings it with the engine). frontier codes a codec point through
uorc::compress_with_strategies over FrameEncoder's planned frames; the
shipped plan writes the shipped stream (tested), and the offline corpus
re-decides to the same claim.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3QshCSRwiddS64zU3j
@afflom
afflom merged commit f355227 into main Nov 11, 2026
17 checks passed
afflom pushed a commit that referenced this pull request Nov 11, 2026
One inspect JSON carries steps (shared with #137) plus the codec point. The
release builds model.json from the factory-decided claims/frontier.toml
(--frontier), attaches both registers, and its notes add the performance rows
and engine line after frontier.md instead of repeating the claims.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3PSU8BqT6iazmFzCy1
afflom pushed a commit that referenced this pull request Nov 11, 2026
The register's portfolio plan reads the engine's table: Plan::shipped is
portfolio::SHIPPED and Plan::strategies is Table::plan; frontier's entry
form re-exports the portfolio's. compress_pieces reads the shipped table,
and compress_stream_with is gone (the register codes points itself).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013Asa3LeJgXkUvvAfeAGt9A
@afflom afflom mentioned this pull request Nov 12, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants