> ## Documentation Index
> Fetch the complete documentation index at: https://docs.bitfield.so/llms.txt
> Use this file to discover all available pages before exploring further.

# Claim ledger

> The fields every public benchmark claim must carry.

<div className="bf-article">
  <p className="bf-lead">
    The claim ledger is the public checklist that keeps speed numbers honest.
  </p>

  Someone wants to reuse a speed number in a page, social card, or launch copy. The ledger tells them which value, unit, category, mechanism, non-claims, and public pages are allowed to carry that row.

  <div className="bf-flow" aria-label="Claim ledger contract">
    <div className="bf-flow-step">
      <span>Claim</span>
      <strong>Number and unit</strong>
      <p>The public value and what is being counted.</p>
    </div>

    <div className="bf-flow-arrow">→</div>

    <div className="bf-flow-step">
      <span>Category</span>
      <strong>Measured job</strong>
      <p>The work shape that makes the claim meaningful.</p>
    </div>

    <div className="bf-flow-arrow">→</div>

    <div className="bf-flow-step">
      <span>Boundary</span>
      <strong>Non-claims</strong>
      <p>The places where the number must not be stretched.</p>
    </div>
  </div>

  Every public speed row needs to be auditable without opening private implementation material.

  ## What this is

  Claim ledger = the structured list of public benchmark claims.

  Each claim has a number, a unit, a measured category, a mechanism, and a list of things the number does not claim.

  ## Required parts

  | Part                       | Meaning                                                               |
  | -------------------------- | --------------------------------------------------------------------- |
  | Claim ID                   | Stable public ID for the claim row.                                   |
  | Public label               | The phrase readers see.                                               |
  | Value                      | The number.                                                           |
  | Unit                       | What the number is counted in.                                        |
  | Category                   | The job measured, such as `warm-local-read` or `durable-batch-write`. |
  | Mechanism categories       | Public mechanism families that explain the claim.                     |
  | Public detail level        | The level of mechanism detail that can be safely explained.           |
  | Mechanism sentence         | Short sentence explaining why this category can have this number.     |
  | Non-claims                 | The boundaries. This stops readers from comparing unlike jobs.        |
  | Private-detail boundary    | The details that public docs must not expose.                         |
  | Pages allowed to repeat it | The public pages that are allowed to use the claim.                   |

  ## Current category names

  | Category                 | Meaning                                                                               |
  | ------------------------ | ------------------------------------------------------------------------------------- |
  | `warm-local-read`        | Local read when the needed bytes are already warm and no network request is included. |
  | `content-address-lookup` | Local lookup where Bitfield resolves a content identity before reading.               |
  | `durable-batch-write`    | Saved-write work measured across a batch.                                             |
  | `batched-write-ceiling`  | Ceiling number for an optimized full-batch path.                                      |

  ## Current claim rows

  | ID                              | Public label                         |  Value | Unit                         | Category                 | Mechanism categories                                    |
  | ------------------------------- | ------------------------------------ | -----: | ---------------------------- | ------------------------ | ------------------------------------------------------- |
  | `h0-warm-local-read`            | 0.68ns warm local read               | `0.68` | nanoseconds per read         | `warm-local-read`        | `memory-mapped-local-read`, `content-addressed-storage` |
  | `h1-hash-lookup`                | 91.7ns hash lookup                   | `91.7` | nanoseconds per lookup       | `content-address-lookup` | `content-addressed-storage`                             |
  | `durable-batch-write-8190`      | 316ns durable batch write comparison |  `316` | nanoseconds per written item | `durable-batch-write`    | `durable-append-path`                                   |
  | `current-batched-write-ceiling` | 0.59ns batched engine write ceiling  | `0.59` | nanoseconds per written item | `batched-write-ceiling`  | `durable-append-path`                                   |

  ## Field-level failure examples

  | Bad row shape                       | Why it fails                                          | Correct row shape                                                                                          |
  | ----------------------------------- | ----------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
  | Value and unit only                 | It cannot be compared safely                          | Value, unit, category, mechanism, and non-claims                                                           |
  | Category says "database speed"      | Too broad to verify                                   | A measured job like `warm-local-read`                                                                      |
  | Non-claims are empty                | The number can be stretched into false claims         | Explicit exclusions for cold, network, lookup, or write boundaries                                         |
  | Allowed-page list is missing a page | The claim can appear where the ledger cannot audit it | Add every public page that repeats the row                                                                 |
  | Forbidden details are not named     | Writers may expose the wrong layer                    | Keep private layouts, private encodings, private scheduling logic, and raw private logs out of public docs |

  ## Public boundary

  Public docs may explain mechanism categories.

  Public docs may not publish private file layouts, private binary record formats, private write scheduling logic, or raw private benchmark logs.

  That is the point of the ledger. It lets the docs show enough mechanism to be credible without turning the docs into a private implementation dump.

  ## Common failures

  | Failure                                    | Why it is wrong                  | Fix                                          |
  | ------------------------------------------ | -------------------------------- | -------------------------------------------- |
  | Page uses a speed number not in the ledger | The source of truth splits       | Add or update the ledger row first           |
  | Claim lacks a non-claim list               | Readers can overread the result  | Add explicit boundaries                      |
  | Claim uses a new category silently         | Comparisons become blurry        | Add the category to validation intentionally |
  | Claim exposes forbidden details            | Public docs leak the wrong layer | Stay at public mechanism-category level      |

  ## Next

  * [Benchmark ledger](/proof/benchmark-ledger)
  * [Measurement methodology](/proof/methodology)
  * [Comparison guardrails](/proof/comparison-guardrails)
</div>
