# CIS-2 — Canonical Floating-Point Semantics for fp32 Transformer Inference, v0.3b

**Status: DRAFT, not frozen.** Private research (Aefinity-AI/cis2-fp). HELD —
not for publication without Justin's explicit decision (2026-08-28 publish
policy). This document is normative for the scope stated below: a
conforming, from-spec-text-only clean-room implementation MUST reproduce
`CIS2_REF` (§12) and the `inv_freq table_digest` (§7.2) bit-for-bit on the
pinned test vectors of §13, on both x86-64 and aarch64.

This is v0.3b of the spec, drafted as v0.1 (`docs/CIS2_SPEC_v0.1.md`), then
v0.2 (`docs/CIS2_SPEC_v0.2.md`), then an intermediate v0.3 (superseded,
kept only in §16's changelog and §6.3/§6.7's history notes). **v0.3b closes
CIS-2's one remaining stated technical limitation** (v0.2 §6.7,
`docs/H2_TRANSCENDENTAL_RIGOR.md`): `sin_pinned`/`cos_pinned` now use an
octant range reduction (`r ∈ [-π/4, π/4]`, quadrant index, §6.3),
f64-staged same as v0.3's attempt, PLUS separate degree-7/8 minimax
polynomials (replacing the degree-10 Taylor series both v0.2 and v0.3
used). v0.3 alone (f64-staged reduction, unchanged Taylor polynomial) fixed
the reduction's catastrophic cancellation but left the *fixed Taylor
polynomial's own truncation error* dominant (up to ~2813 ULP even after the
reduction fix) — a PARTIAL result, documented in `docs/E15m_RESULT.md`.
v0.3b's minimax-polynomial-on-a-smaller-octant approach reaches **≤2 ULP**
vs. a correctly-rounded fp32 oracle across the full RoPE position domain
(`pos ∈ [0, 8192)`), closing the bar v0.3 missed. This changes **only**
§6.3 and §6.6 (`table_digest`, which now hashes one f64 octant-reduction
constant plus 6 minimax coefficients in place of the prior reduction
constant(s) and Taylor tables); RoPE's `inv_freq` construction (§7.1,
`ln_pinned`/`exp_pinned`) and `inv_freq_table_digest` (§7.2) are
**unaffected** by anything in this task. `CIS2_REF` and `table_digest`
**both changed at each step** (v0.2→v0.3→v0.3b; §16 has the full changelog
and all digest values); `inv_freq_table_digest` does **not** change at any
step. Full design rationale, determinism justification, and honest
gate-by-gate results (including v0.3's partial miss): `docs/E15m_PREREG.md`
(pre-registered before implementation) and `docs/E15m_RESULT.md`
(post-implementation gate results for both v0.3 and v0.3b). This
document's body is, as with v0.1/v0.2, written to be implementable
**without** access to `src/` — Appendix A cites exact `file:line`s only so
a reviewer can audit that this spec did not silently diverge from what the
reference actually computes.

**What conformance buys:** bit-identical fp32 decode of
`HuggingFaceTB/SmolLM2-135M` given the pinned prompt (§13), reproducible by
an independent from-spec-text implementation, on any ISA that supports
IEEE-754 binary32 arithmetic with FTZ/DAZ control (x86-64 MXCSR, aarch64
FPCR.FZ). Unlike v0.1, this version's RoPE construction (§7) is
**theta-general**: it is defined for any `rope_theta` value read from
`config.json`, not just `100000.0`, and has been exercised against a second
model family (`Qwen/Qwen2.5-0.5B`, `rope_theta = 1000000`) under an
independent oracle (`docs/E15d_bc_RESULT.md`). This is still deliberately
narrower than CIS-1 (§1 of `docs/CIS-1_SPEC_v1.0.md` in the public `Aefinity-AI/alice-aegis` repository, https://github.com/Aefinity-AI/alice-aegis):
floating-point addition is not associative, so this spec does not claim "any
reduction order is safe" — it claims exactly one pinned reduction order, one
pinned transcendental route (now including a pinned general `ln`), and one
pinned digest encoding are collectively sufficient for bit-identity, and
states each of them exactly.

---

## 0. Scope and non-goals (normative)

This spec's primary pinned tuple is unchanged from v0.1: `HuggingFaceTB/SmolLM2-135M`, prompt
`"Once upon a time"`, 16 greedy-decoded tokens, fp32 compute, bf16-on-disk
weights. §7's RoPE construction is now general (any `rope_theta`), so a
second (model, prompt, decode-length) tuple — `Qwen/Qwen2.5-0.5B`,
`rope_theta = 1_000_000` — is evidence-of-correctness (`docs/E15d_bc_RESULT.md`)
but is **not** itself a pinned §13 test vector in this version; only the
SmolLM2-135M tuple's digests are normative test vectors here. It does **not**
claim:

- General correctness of the pinned transcendental polynomials (`exp`,
  `sin`, `cos`, `ln`) outside the input ranges actually exercised by the
  decodes checked so far (§14.4, carried from v0.1, and §14.1 new-in-v0.2 for
  `ln_pinned`'s domain).
- Cross-framework agreement (vs. PyTorch/`transformers`) as a conformance
  requirement — oracle comparisons (§13.3, `docs/E15b_m1p5_CORRECTNESS.md`,
  `docs/E15d_bc_RESULT.md`) are evidence of correctness, not a conformance
  requirement; CIS-2 conformance is defined relative to this document's own
  bits, not to any third-party framework's output.
- Seeded/temperature sampling — decode is greedy-only (argmax every step),
  matching CIS-1's own non-goal (CIS-1 §10).
- Anything about `verify/` or `cis2-verify2` (independently-written
  clean-room implementations built by *not* reading `src/`, used only to
  find gaps in earlier drafts of this document — evidence this spec was
  tested against, not itself normative). A clean-room re-verification of
  this exact v0.2 document against `cis2-verify2` is tracked separately
  (`docs/E15h_verify2_v0.2` lineage) and is not required for this document's
  own normative status.

## 1. Floating-point environment (normative)

**Unchanged from v0.1.** Reproduced verbatim (renumbered where v0.1 section
numbers shifted below, otherwise identical text and identical pinned
values):

1.1. **Format**: IEEE-754 binary32 (`f32`) for all decode-path compute.
Weights are stored on disk as `bfloat16` and widened to `f32` per §4.2
before any arithmetic.

1.2. **Rounding mode**: round-to-nearest-even (RNE), the IEEE-754 default,
for every basic operation (`+`, `-`, `*`, `/`, `sqrt`). No other rounding
mode is set at any point in the decode path. Nothing in this spec changes
the FPU/SIMD rounding-mode control bits from their IEEE-754 default.

1.3. **FTZ/DAZ MUST be pinned on, on every ISA, before any decode-path fp32
arithmetic runs:**
   - x86-64: MXCSR bit 15 (FTZ) and bit 6 (DAZ) both set to 1, via direct
     read-modify-write of the MXCSR register (not the deprecated
     `_MM_SET_*` wrapper macros). A conforming implementation MUST assert
     (readback, not just "we called the setter") that both bits are 1
     before proceeding.
   - aarch64: FPCR bit 24 (FZ) set to 1, via `mrs`/`msr fpcr`. aarch64 has
     no separate DAZ control; FZ alone flushes both denormal inputs and
     denormal outputs for scalar and Advanced SIMD binary32/binary64
     arithmetic. FPCR bit 19 (FZ16, half-precision flush-to-zero) is left
     at its architectural default (this reference never uses fp16) — do
     not set it. A conforming implementation MUST assert (readback) that
     FZ is 1 before proceeding.
   - Any other ISA: undefined by this version of the spec; a conforming
     implementation MUST refuse to run (hard compile-time or run-time
     error) rather than silently proceed without an equivalent control.
   - **Adversarial self-test (MUST run and pass before decode)**: with
     FTZ/DAZ pinned, `f32::MIN_POSITIVE (2^-126) * 1.0e-10` MUST equal
     exactly `+0.0` (not a subnormal), and the smallest positive subnormal
     bit pattern `0x00000001` added to `+0.0` MUST also equal exactly
     `+0.0`. (This must be checked with the operands passed through an
     optimization barrier — e.g. Rust's `std::hint::black_box` — so the
     compiler cannot fold the arithmetic away and mask a broken pin.)

1.4. **No FMA contraction, anywhere, in the reference.** Every
multiply-then-add in this spec is defined as **two separate, separately
RNE-rounded operations**: compute the product, round to `f32`; then add,
round to `f32` again. A single fused `a*b+c` with one rounding step is
**non-conforming** even though it may be "more accurate" — it produces
different bits. In Rust terms: never call `f32::mul_add`; write `a*b + c`
as two statements/expressions, which LLVM does not auto-fuse absent an
explicit fast-math flag Rust does not provide. A conforming implementation
in any language MUST mechanically verify (e.g., disassemble the release
binary and grep for `vfmadd*`/`vfnmadd*`/`vfmsub*`/`vfnmsub*`/`fmadd`/
`fmsub` on the target ISA) that the emitted machine code contains zero
fused multiply-add instructions on the decode path. This has now been
mechanically verified across 20 compiler configurations (opt-level ×
target-cpu × ISA) with a reproducing pre-registered digest — see §13.4,
new in v0.2.

1.5. **No fast-math, no reassociation.** The compiler MUST NOT be given
any flag that licenses reassociating floating-point expressions, assuming
no NaN/Inf, or substituting approximate reciprocal/rsqrt hardware
instructions (e.g. `-ffast-math`, `-Ofast`, `-freciprocal-math`). This
spec's reduction orders (§5) are only bit-determining if the compiler
computes exactly the sequence of operations stated, in the stated order.

1.6. **Division and sqrt**: ordinary IEEE-754 `/` and `sqrt` (both
mandatory-correctly-rounded operations under IEEE-754), never a
reciprocal-approximation instruction (x86 `rcpps`/`rsqrtps`, ARM
`frecpe`/`frsqrte`) and never a library "fast inverse sqrt" trick. Any
conformant IEEE-754 binary32 `sqrt`/`/` implementation on any ISA produces
identical bits for identical inputs, by the standard itself — this is the
one part of the arithmetic this spec does not need to additionally pin.

## 2. Model artifact (normative)

**Unchanged from v0.1** (verbatim, all pinned values identical):

2.1. **Source**: Hugging Face repo `HuggingFaceTB/SmolLM2-135M`, files
fetched from the public `resolve/main/` URLs (no authentication required,
repo is public). No git revision/commit hash is pinned beyond content —
the artifact is identified **only** by the sha256 hashes below, which is
strictly stronger than a mutable branch ref:

| file | sha256 |
|---|---|
| `model.safetensors` | `80521b40281d6ce74e35c9282c22539e75aa0ac8578892b2a59955ef78d55da1` |
| `config.json` | `1d556eab73b69c7f11f64c557a2f9c6f440bd4c6b89bb2584a6b498c92603843` |
| `tokenizer.json` | `9ca9acddb6525a194ec8ac7a87f24fbba7232a9a15ffa1af0c1224fcd888e47c` |

A conforming implementation MUST verify all three sha256 hashes before use
and MUST fail loudly (not silently proceed) on mismatch.

2.2. **Architecture parameters**, taken from `config.json` (a conforming
implementation MUST read these from the file, not hardcode them, but their
pinned values for this artifact are, for the reader's convenience):

| field | value |
|---|---|
| `hidden_size` | 576 |
| `intermediate_size` | 1536 |
| `num_hidden_layers` | 30 |
| `num_attention_heads` | 9 |
| `num_key_value_heads` | 3 |
| `hidden_act` | `silu` |
| `rms_norm_eps` | `1e-05` (f64 in JSON; §2.3 pins its f32 cast) |
| `rope_theta` | `100000` (`100000.0`) |
| `rope_interleaved` | `false` |
| `max_position_embeddings` | 8192 |
| `tie_word_embeddings` | `true` |
| `torch_dtype` | `bfloat16` |
| `vocab_size` | 49152 |

Derived: `head_dim = hidden_size / num_attention_heads = 576/9 = 64`
(exact integer division); `group = num_attention_heads / num_key_value_heads
= 9/3 = 3` (GQA group size); `half = head_dim/2 = 32`.

2.3. **`rms_norm_eps` f32 cast**: the JSON value `1e-05` is parsed as an
IEEE-754 `f64` (`1.0e-5`), then cast to `f32` via a single RNE rounding
(Rust `as f32`, equivalent to any IEEE-754-conformant `f64`→`f32`
narrowing conversion). Pinned bit pattern:

```
EPS_F32 = 0x3727C5AC   (== (1.0e-5f64) as f32)
```

2.4. **`rope_theta` restriction — REMOVED in v0.2** (v0.1's §2.4 required
`rope_theta == 100000.0` exactly and refused to run otherwise; §7's
theta-general construction removes this restriction, closing v0.1 §14.1 —
see §7 and §16).

2.5. **Tensor names and shapes** (row-major, `[out_features, in_features]`
for every linear layer, matching PyTorch's `nn.Linear.weight` layout — a
matvec is `y[o] = Σ_i w[o,i]·x[i]`, §5.1):

```
model.embed_tokens.weight                              [vocab, hidden]
model.layers.{i}.input_layernorm.weight                [hidden]                for i in 0..30
model.layers.{i}.post_attention_layernorm.weight       [hidden]
model.layers.{i}.self_attn.q_proj.weight               [hidden, hidden]
model.layers.{i}.self_attn.k_proj.weight               [n_kv_heads*head_dim, hidden]
model.layers.{i}.self_attn.v_proj.weight               [n_kv_heads*head_dim, hidden]
model.layers.{i}.self_attn.o_proj.weight               [hidden, hidden]
model.layers.{i}.mlp.gate_proj.weight                  [inter, hidden]
model.layers.{i}.mlp.up_proj.weight                    [inter, hidden]
model.layers.{i}.mlp.down_proj.weight                  [hidden, inter]
model.norm.weight                                      [hidden]
```

There is **no** separate `lm_head.weight` tensor in this checkpoint
(confirmed by safetensors header inspection: 272 tensors total, all
`BF16`, no `lm_head.*` name present) — this matches
`tie_word_embeddings: true`. The LM head matmul (§11) reuses
`model.embed_tokens.weight` directly as the `[vocab, hidden]` output
projection matrix; no separate weight is loaded or derived for it.

Every tensor's on-disk dtype is `BF16` (2 bytes/element, little-endian
16-bit pattern per element, raw `safetensors` payload bytes taken two at a
time as `u16::from_le_bytes`). Every tensor MUST be widened per §4.2
before use; no tensor is used in bf16 form at compute time.

**Informative, v0.2**: a second model family, `Qwen/Qwen2.5-0.5B`
(different `rope_theta`, GQA shape, `attention_bias=true` on q/k/v
projections, optionally untied `lm_head.weight`), has been run through the
same reference code path unmodified beyond config-driven parameters
(`docs/E15d_bc_RESULT.md`). This is evidence the reference's architecture
handling generalizes; it is not a second pinned §13 test vector in this
version.

## 3. Tokenizer, prompt, and decode protocol (normative)

3.1. **Tokenizer.** **v0.2.1 (H4, this section): fully re-specified,
closing H3 BLOCKER-2** (`docs/H3_SPEC_AUDIT.md`; carried forward from
`verify3/SPEC_GAPS_v0.2.md` items 1–2). v0.1/v0.2's text ("loaded as a
complete, self-contained HuggingFace `tokenizers`-format tokenizer
(BPE-family; the exact merge/vocab table is entirely contained in this one
file — no external vocab/merges files, no additional special-token config
beyond what `tokenizer.json` itself specifies)") is retained but is no
longer the full normative surface: it is necessary but not sufficient, since
it does not define the BPE algorithm, the pretokenizer, the byte-level
mapping, or the merge tie-break rule. Those are pinned below.

3.1.1. **Artifact.** The `tokenizer.json` file shipped with the checkpoint,
bound by content hash: `sha256(tokenizer.json) =
9ca9acddb6525a194ec8ac7a87f24fbba7232a9a15ffa1af0c1224fcd888e47c` (§2.1's
table, repeated here for locality). A conforming implementation MUST verify
this hash before use. This one file is self-contained: it embeds the full
vocab (49152 entries), the full ordered merge-rank list (48900 pairs), the
pre-tokenizer config, and the 17 special/added tokens (§3.1.6) — no external
vocab.json/merges.txt/tokenizer_config.json is consulted.

3.1.2. **Reference library binding (normative fallback).** The reference
implementation calls the Rust `tokenizers` crate, version **0.23.1**
(`Cargo.lock`; upstream source
`https://crates.io/crates/tokenizers/0.23.1`), specifically
`tokenizers::Tokenizer::from_file(&tokenizer_path)` then
`.encode(prompt, false)` (`src/main.rs:487-488,536`). Per this spec's
preference for algorithm over library citation: §3.1.3–3.1.6 below give the
byte-level BPE algorithm in full, transcribed from that crate's source
(`src/pre_tokenizers/byte_level.rs`, `src/pre_tokenizers/digits.rs`,
`src/models/bpe/word.rs`, `src/models/bpe/model.rs`, all at tag `v0.23.1`)
and independently verified in this audit to reproduce §3.3's pinned
token ids using the Python `tokenizers` binding (same crate, same version
family) loading the actual downloaded `tokenizer.json`. If any future
implementer finds an algorithmic edge case this section under-specifies,
`tokenizers` crate v0.23.1's published source is the normative
tie-breaker — this citation, not just the informal "HuggingFace
`tokenizers`-format" phrase, is part of the normative surface (the same
pattern this spec already uses for `sha256` as an external cited standard,
§2.1).

3.1.3. **Pipeline, in order:** normalizer (none — `tokenizer.json`'s
`normalizer` field is `null`) → pre-tokenizer (§3.1.4, splits the input
string into a sequence of "words") → per-word byte-level BPE encode
(§3.1.5) → no post-processor (`tokenizer.json`'s `post_processor` field is
`null`; this is what makes `add_special_tokens=false`, §3.3, produce zero
inserted tokens rather than a template).

3.1.4. **Pre-tokenizer.** `tokenizer.json`'s `pre_tokenizer` field is
`{"type": "Sequence", "pretokenizers": [
{"type": "Digits", "individual_digits": true},
{"type": "ByteLevel", "add_prefix_space": false, "trim_offsets": true,
"use_regex": true}]}`. Applied in list order to the raw Unicode input
string:
  a. **Digits** (`individual_digits=true`): split the string at every
     maximal run of Unicode-numeric characters (`char::is_numeric`),
     *isolating* each individual digit as its own one-character segment
     (contrast with `individual_digits=false`, which would keep a digit
     run together — not used here). Non-digit segments pass through
     unsplit. (No digits occur in the pinned prompt `"Once upon a time"`,
     so this stage is a no-op on the §13.1 test vector but MUST still be
     applied for other inputs.)
  b. **ByteLevel** (`add_prefix_space=false`, `use_regex=true`): for each
     segment from (a), do NOT prepend a space (this checkpoint's config
     differs from the GPT-2 default of `add_prefix_space=true`); then
     split it further using the literal GPT-2 pre-tokenizer regex,
     applied with Unicode property classes, isolated-delimiter semantics
     (each match becomes its own segment, unlike the ordinary
     split/no-delimiter mode):
     ```
     's|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+
     ```
     (verbatim from `tokenizers` crate `src/pre_tokenizers/byte_level.rs`,
     itself citing `https://github.com/openai/gpt-2/blob/master/src/encoder.py#L98`).
     Then, for every resulting segment, remap **every UTF-8 byte** of that
     segment's text through the byte→unicode table of §3.1.5.a, producing
     a string of the same byte-count length (each input byte becomes
     exactly one output Unicode codepoint). This byte-remapped string is
     the final "word" handed to the BPE model (§3.1.5).

3.1.5. **Byte-level BPE model** (`tokenizer.json`'s `model` field: `type =
"BPE"`, `dropout = null`, `unk_token = null`, `continuing_subword_prefix =
null`, `end_of_word_suffix = null`, `fuse_unk = false`,
`byte_fallback = false`, `ignore_merges = false`). `dropout = null` means
the merge process below is fully deterministic (no probabilistic merge
skipping); `unk_token = null` and `byte_fallback = false` are moot because
the byte-level remap of 3.1.4.b guarantees every input byte already maps to
some single-character token that is a base entry in `vocab` (step a below),
so the "no matching vocab entry" branch is never taken for any input.
  a. **Byte→unicode map construction** (verbatim from
     `tokenizers` crate `bytes_char()`, itself following
     `https://github.com/openai/gpt-2/blob/master/src/encoder.py#L9`):
     starting from the empty list, let `bs` = the 188 byte values in the
     three ranges `0x21..=0x7E` (`!`..`~`), `0xA1..=0xAC`, `0xAE..=0xFF`,
     each mapped to itself as a Unicode codepoint (`char::from_u32(b as
     u32)`); then, in ascending byte order `0..=255`, for every byte `b`
     NOT already in `bs`, append `b` to `bs` and map it to codepoint
     `256 + n` where `n` is a counter starting at 0 and incremented after
     each such assignment. This produces a total bijection over all 256
     byte values (188 map to themselves as printable-ASCII/Latin-1
     codepoints, the remaining 68 — control chars, space, DEL, and the
     `0x7F..=0xA0`/`0xAD` gap — map to codepoints `256..323`, e.g. byte
     `0x20` (space) maps to U+0120 `Ġ`, byte `0x0A` (newline) maps to
     U+010A `Ċ`). Decode uses the inverse map; both directions are
     computed once from this same construction, never independently
     hand-tuned per direction.
  b. **Initial symbol sequence.** For each byte-remapped "word" string
     from §3.1.4.b: split it into individual Unicode characters (one
     character = one original input byte, by construction of 3.1.4.b/3.1.5.a);
     look each single character up in `vocab` (the base single-byte
     vocabulary entries, ids 18–273 in this tokenizer's vocab, are exactly
     the 256 codepoints of 3.1.5.a, so this lookup always succeeds — see
     the `unk`/`byte_fallback` note above); the resulting list of
     `(vocab_id, byte_length=1)` pairs, in original left-to-right order, is
     the word's initial symbol sequence.
  c. **Merge loop (deterministic, rank-ordered, leftmost-tie-break).**
     `tokenizer.json`'s `model.merges` is an ordered list of 48900 symbol
     pairs; its list position IS the pair's merge rank (rank 0 = highest
     priority, applied first; rank 48899 = lowest). Given the initial
     symbol sequence from (b):
     i.   Build a priority queue seeded with every adjacent pair in the
          current symbol sequence that appears in `model.merges`, each
          keyed `(rank, position)`.
     ii.  Repeatedly pop the queue entry with the **lowest rank**; if two
          queued entries have equal rank (impossible here since merge
          ranks are a total order over distinct pairs, but stated for
          completeness as the crate's own tie-break), the entry with the
          **lower (leftmost) position** wins.
     iii. Before applying a popped entry, re-validate it still describes
          an adjacent, unmerged pair at that position (earlier merges may
          have invalidated it); if stale, discard and continue.
     iv.  Apply the merge: replace the two symbols with one symbol whose
          vocab id is `model.merges[rank]`'s resulting token id (from
          `tokenizer.json`'s corresponding `model.vocab` entry for the
          concatenated string) and whose byte-length is the sum of the
          two merged symbols'; enqueue any newly-adjacent mergeable pairs
          this creates (with the previous and/or next symbol) at their
          own rank.
     v.   Repeat ii–iv until the queue is empty. The final symbol sequence
          (in order) is that word's token id sequence.
  d. **Concatenation.** The prompt's full token id sequence is the
     concatenation, in original left-to-right order, of every word's token
     id sequence from (c), across all words produced by §3.1.4.

3.1.6. **Special/added tokens.** `tokenizer.json`'s `added_tokens` array
pins 17 special tokens, ids 0–16 (`<|endoftext|>`, `<|im_start|>`,
`<|im_end|>`, `<repo_name>`, `<reponame>`, `<file_sep>`, `<filename>`,
`<gh_stars>`, `<issue_start>`, `<issue_comment>`, `<issue_closed>`,
`<jupyter_start>`, `<jupyter_text>`, `<jupyter_code>`, `<jupyter_output>`,
`<empty_output>`), each with `special: true`. Per §3.3,
`add_special_tokens = false` means **none** of these are inserted for the
pinned prompt — no BOS (`<|endoftext|>`, id 0, is this tokenizer's only
BOS/EOS-like token and is never emitted for this prompt), no EOS, no
chat-template tokens. This is why the pinned `prompt_token_ids` (§3.3) has
exactly 4 entries, not 5 or more.

3.1.7. **Worked example — self-check before running the model.** Applying
§3.1.3–3.1.6 to the pinned prompt `"Once upon a time"` (§3.2):
  - No digits (§3.1.4.a is a no-op).
  - ByteLevel regex (§3.1.4.b) with `add_prefix_space=false` splits the
    ASCII string into 4 words: `"Once"`, `" upon"`, `" a"`, `" time"`
    (each of the latter three carries its leading space per the ` ?\p{L}+`
    alternative). Byte-remapping (§3.1.5.a) maps each literal space byte
    `0x20` to `Ġ` (U+0120) and leaves all other ASCII letters unchanged
    (they are in the `0x21..=0x7E` self-mapped range), giving the 4
    byte-remapped words `"Once"`, `"Ġupon"`, `"Ġa"`, `"Ġtime"`.
  - Per-word BPE merge (§3.1.5.b–d) on this tokenizer's `vocab`/`merges`
    reduces each word to exactly **one** token each (each whole word is
    itself a `vocab` entry reachable by the merge sequence — a property of
    this particular checkpoint's trained merge table for these four common
    words, not a general guarantee): `"Once"` → id `6403`, `"Ġupon"` → id
    `1980`, `"Ġa"` → id `253`, `"Ġtime"` → id `655`.
  - Concatenation (§3.1.5.d) with no special tokens (§3.1.6, §3.3) gives
    ```
    prompt_token_ids = [6403, 1980, 253, 655]
    ```
    — bit-for-bit the pinned value already stated in §3.3 and reproduced
    in §13.1. An implementer can check their own tokenizer stage against
    this worked example (word segmentation, byte remap, and final ids)
    *before* running any model math, isolating tokenizer bugs from
    numeric-core bugs.

3.1.8. **Cross-check performed for this section (informative, not itself
part of the normative text).** The exact `tokenizer.json` cited by §3.1.1's
hash was fetched from `https://huggingface.co/HuggingFaceTB/SmolLM2-135M/
resolve/main/tokenizer.json`; its sha256 was confirmed to equal
`9ca9acddb6...` (§3.1.1) byte-for-byte; loading it with the Python
`tokenizers` library (`Tokenizer.from_file(...).encode("Once upon a time",
add_special_tokens=False)`) reproduced `[6403, 1980, 253, 655]` exactly,
confirming both this section's transcription of the algorithm and its
worked example (§3.1.7) against a live run of the actual pinned artifact —
not merely against source-code reading.

3.2. **Prompt**: the literal ASCII string `Once upon a time` (no
leading/trailing whitespace beyond what is written here, no chat template
applied, no system prompt, no BOS/EOS token added or implied by any
wrapper). This is raw next-token completion, not chat-formatted.

3.3. **BOS/special-token handling**: tokenization MUST be performed with
`add_special_tokens = false` (i.e. the tokenizer's raw BPE encode of the
prompt string only — no BOS, no EOS, no any other special token
prepended/appended). Pinned result:

```
prompt_token_ids = [6403, 1980, 253, 655]     (4 tokens, u32)
```

3.4. **Decode protocol**: greedy only (argmax every step, §11.2), no
sampling, no temperature, no top-k/top-p. Exactly **16** tokens are
generated after the 4-token prompt, unconditionally — **EOS is not
checked and does not stop generation early** (matching CIS-1's own Tier-3
"EOS ignored" precedent, CIS-1 spec §8). Position indices are
`0, 1, 2, 3` for the 4 prompt tokens (prefill) and `4, 5, ..., 19` for the
16 generated tokens, assigned strictly in generation order (prompt
positions first, generated positions immediately following, no gaps, no
re-indexing).

3.5. **KV-cache equivalence (informative, not itself a conformance
requirement)**: the reference recomputes attention incrementally with a
KV cache that stores exactly the post-RoPE K/V vectors a from-scratch
full-recompute-per-step forward pass would produce (pure memoization, not
a reduction-order change). §14.5 (v0.1 numbering) independently confirms
the cached and oracle (full-recompute, no cache) paths agree. A conforming
implementation MAY use a KV cache or MAY recompute from scratch each
step; both are conformant iff they produce bit-identical logits — this
spec pins the *math*, not the caching strategy.

## 4. bf16 → fp32 widening (normative)

**Unchanged from v0.1** (verbatim):

4.1. **Formula**: exact, lossless bit-shift, not a rounding conversion.
For a bf16 value with raw 16-bit pattern `b` (as loaded via
`u16::from_le_bytes` on the 2 little-endian bytes of that element in the
safetensors payload):

```
f32_bits = (b as u32) << 16
widened  = f32::from_bits(f32_bits)
```

This is exact because bf16's sign(1)/exponent(8)/mantissa(7) layout is
identical to fp32's top 16 bits with the low 16 mantissa bits defined as
zero — bf16's exponent field has the same width and bias as fp32's, so
there is no exponent range issue and no rounding decision to make. This
MUST be implemented as the literal bit operation above, not as a call
through any "convert" library routine that might round or normalize
differently.

4.2. Every tensor listed in §2.5 is widened element-wise via §4.1 at load
time before any arithmetic touches it. No tensor is used in bf16 form.

## 5. Numeric reduction primitives (normative)

**Unchanged from v0.1** (verbatim):

5.1. **Sequential dot product.** For vectors `a`, `b` of equal length `n`:

```
acc = 0.0_f32
for i in 0..n:
    p   = a[i] * b[i]     # separate multiply, RNE-rounded to f32
    acc = acc + p          # separate add, RNE-rounded to f32
return acc
```

Strictly left-to-right, index order `0, 1, ..., n-1`. No pairwise tree, no
chunking, no reordering by magnitude. This is the **only** conforming
reduction order for every dot product and every "sum of products" loop in
this spec (matvec rows §5.2, attention score dot §9.2, V-mix §9.4).
`dot_seq` is order-sensitive by design: dotting `[1e8, 1.0, -1e8]` against
`[1.0, 1.0, 1.0]` in this order gives exactly `0.0_f32` (the `1.0` term is
lost to rounding against the `1e8` partial sum) — any other order gives a
different, nonzero answer; a conforming implementation MUST reproduce
`0.0_f32` on this specific input as a regression check.

5.2. **Matvec.** `y[o] = dot_seq(w[o, :], x)` for `o = 0..out_features`,
where `w[o, :]` is row `o` of the row-major `[out_features, in_features]`
weight tensor (§2.5). Each output element is one independent §5.1 dot
product; rows may be computed in any order or in parallel relative to
each other (row order does not affect any single row's bits), but each
row's own reduction MUST use §5.1's exact order.

5.3. **Sequential sum.** For a vector `a` of length `n` (used for
sum-of-squares in RMSNorm §8 and the softmax denominator §10):

```
acc = 0.0_f32
for i in 0..n:
    acc = acc + a[i]      # separate add, RNE-rounded to f32
return acc
```

Same left-to-right, no-reassociation rule as §5.1.

5.4. **Elementwise add** (residual connections, §9.5/§10.3, and optional
QKV bias, §9.1 new-in-v0.2): plain `out[i] = a[i] + b[i]` for every `i`,
one IEEE-754 add each, no reduction involved.

## 6. Transcendental functions (normative)

There are now **three** routes (v0.1 had two); this spec pins all three
exactly. §6.1/§6.2/§6.3 are unchanged from v0.1; §6.5 is new in v0.2.

### 6.1 rsqrt — route (a), correctly-rounded, no table

```
rsqrt(x) = 1.0_f32 / x.sqrt()
```

Composed from two IEEE-754-mandatory correctly-rounded operations
(`sqrt`, then `/`). Because both are mandatory-correctly-rounded under the
standard, **any** conformant IEEE-754 binary32 implementation on any ISA
produces identical bits for identical `x` — no coefficient table, no
digest, no pinning needed beyond "use the standard's `sqrt` and `/`, not
an approximate hardware reciprocal-sqrt instruction" (already stated in
§1.6). `rsqrt(64.0) == 0.125` exactly (`0x3E000000`) is a conformance
check.

### 6.2 exp — route (b), pinned Cephes-pattern polynomial

For `x` a finite `f32`:

1. If `x` is NaN, return NaN.
2. If `x > 88.0`, return `+Infinity`.
3. If `x < -88.0`, return `0.0`.
4. Range reduction: find integer `k` and remainder `r` such that
   `x ≈ k·ln(2) + r`, `|r|` small, via:
   ```
   t   = x * EXP_LOG2E          # x / ln(2), separate mul
   z0  = t + 0.5
   k   = floor(z0)               # k as f32, truncated toward -inf at z0
   kc1 = k * EXP_C1
   r0  = x - kc1
   kc2 = k * EXP_C2
   r   = r0 - kc2                 # two-part ln(2) split, Cephes pattern
   ```
5. Polynomial evaluation (Horner, strict left-to-right, descending
   coefficient index, no FMA):
   ```
   r2   = r * r
   poly = EXP_P[0]
   for i in 1..=5:
       poly = poly * r + EXP_P[i]
   m1     = poly * r2
   poly2  = m1 + r
   result = poly2 + 1.0
   ```
   (This computes `exp(r) ≈ 1 + r + r²·P(r)` with `P` the degree-5
   polynomial `EXP_P[0]·r⁵ + EXP_P[1]·r⁴ + ... + EXP_P[5]`.)
6. Reconstruct `exp(x) = 2^k · result` via **exact bit manipulation** of
   the `f32` exponent field (`ldexp_exact`, §6.2.1) — not a library
   `ldexp`/multiply-by-power-of-2-computed-as-a-float call.

Pinned coefficients (`f32` bit patterns, hex, big-endian digit order of
the 32-bit pattern as conventionally written — i.e. `0xSEEEEEEE MMMMMMM`
read as one `u32`):

```
EXP_LOG2E = 0x3FB8AA3B   (1/ln2)
EXP_C1    = 0x3F318000   (ln2 hi)
EXP_C2    = 0xB95E8083   (ln2 lo, negative)
EXP_P[0]  = 0x39506967
EXP_P[1]  = 0x3AB743CE
EXP_P[2]  = 0x3C088908
EXP_P[3]  = 0x3D2AA9C1
EXP_P[4]  = 0x3E2AAAAA
EXP_P[5]  = 0x3F000000   (== 0.5 exactly)
```

#### 6.2.1 `ldexp_exact(x, k)` — exact scale-by-power-of-2

```
if x == 0.0: return x
bits     = x.to_bits()
exp_bits = (bits >> 23) & 0xFF          # 8-bit biased exponent field
new_exp  = exp_bits + k                  # k is a signed integer
if new_exp <= 0:   return 0.0             # underflow — FTZ/DAZ (§1.3) governs anyway
if new_exp >= 0xFF: return (x.is_sign_negative() ? -Infinity : +Infinity)
new_bits = (bits & !(0xFF << 23)) | (new_exp << 23)   # replace exponent field only
return f32::from_bits(new_bits)
```
Sign and mantissa bits are untouched; only the 8-bit exponent field is
replaced. This is exact (no rounding) whenever the result stays in the
normal-or-flush range, which the `exp()` domain clamp (steps 2–3) and the
saturation branches above guarantee.

### 6.3 sin/cos — route (b), octant reduction + SEPARATE minimax polynomials (CHANGED in v0.3b — supersedes v0.3, closes v0.2 §6.7's finding)

**History (repeated here for §16's changelog):**
- **v0.2's construction** (no longer normative): a two-part-π split
  (`TWO_PI_HI`/`TWO_PI_LO`) done entirely in `f32`. Found
  (`docs/H2_TRANSCENDENTAL_RIGOR.md`, v0.2 §6.7) to suffer catastrophic
  cancellation growing with the RoPE angle's magnitude, up to 1104 ULP /
  1e-4 relative error by decode position 19, and ~0.58 relative
  (unusable) toward `max_position_embeddings = 8192` — an accuracy
  defect, not a determinism defect.
- **v0.3's construction** (no longer normative, superseded by v0.3b
  below): fixed the reduction by staging it through `f64` (exact widen,
  correctly-rounded f64 div/round/mul/sub, correctly-rounded narrow back
  to f32) while keeping v0.2's degree-10 Taylor polynomials on the
  resulting `r ∈ [-π, π]` unchanged. This closed the *reduction's*
  accuracy defect (reduced remainder now accurate to a few ULP of f64,
  utterly negligible next to f32's own ULP) but left the *fixed Taylor
  polynomial's own truncation error* as the dominant remaining term,
  worst near `|r| ≈ π` and near `sin(r)`/`cos(r)` zero crossings — up to
  ~2813 raw ULP / 486 ULP filtered away from zero crossings even after
  the reduction fix, missing this spec family's pre-registered ≤2-ULP
  accuracy bar (`docs/E15m_PREREG.md`, `docs/E15m_RESULT.md`'s v0.3
  section — reported honestly as a partial result, not silently narrowed).

**v0.3b's construction (normative).** Reducing to a *quarter*-period
octant (`r ∈ [-π/4, π/4]`, quadrant index `k mod 4`) instead of a full
period (`r ∈ [-π, π]`) lets a much lower-degree **minimax** polynomial
(fit to minimize worst-case error over the whole reduced interval, rather
than a Taylor series truncated at an arbitrary degree) reach far better
accuracy across that smaller domain. Still f64-staged (same determinism
argument as v0.3), still no FMA, still no fast-math/reassociation (§1.4/
§1.5):

**Reduction** (Cody–Waite pattern, f64-staged, strict left-to-right):

```
xd    = x as f64                  # exact widening cast, f32 -> f64, zero rounding error
k     = round(xd / PI_2_F64)      # f64 division (correctly rounded), then round-to-
                                   # nearest-integer, ties away from zero (f64::round()
                                   # semantics: pure function of the input bit pattern,
                                   # no ISA-dependent instruction selection, §1.5)
khi   = k * PI_2_F64               # f64 multiply (correctly rounded)
r64   = xd - khi                   # f64 subtract (correctly rounded)
r     = r64 as f32                 # single correctly-rounded f64 -> f32 narrowing cast
quadrant = ((k as i64) % 4 + 4) % 4  # k is exact (small integer in f64), cast to i64 losslessly
```

```
PI_2_F64 = 0x3FF921FB54442D18   (f64 bit pattern; == 1.5707963267948966, the
                                 correctly-rounded f64 value of pi/2)
```

**Why f64-staging suffices instead of full Payne-Hanek**: unchanged
argument from v0.3 (`docs/E15m_PREREG.md`) — the RoPE angle is bounded,
`|x| = |pos · inv_freq[i]| < max_position_embeddings = 8192` (§2.2, §7.1),
which leaves ample f64 mantissa headroom regardless of whether the modulus
is `2π` or `π/2`.

**Polynomials** (Cephes `sinf`/`cosf`'s minimax coefficients — long
public-domain algorithm shape, coefficients independently pinned as
literal f32 bit patterns per this spec's own convention, §6.2's preamble):
for `r ∈ [-π/4, π/4]`, strict left-to-right, no FMA:

```
# sin(r) = r + r^3 * (SIN_C0 + r^2 * (SIN_C1 + r^2 * SIN_C2))
r2      = r * r
inner   = SIN_C2
inner   = inner * r2 + SIN_C1
inner   = inner * r2 + SIN_C0
r3      = r2 * r
term    = inner * r3
sin_r   = r + term

# cos(r) = 1 - r^2/2 + r^4 * (COS_C0 + r^2 * (COS_C1 + r^2 * COS_C2))
r2      = r * r
inner   = COS_C2
inner   = inner * r2 + COS_C1
inner   = inner * r2 + COS_C0
r4      = r2 * r2
term    = inner * r4
half_r2 = 0.5 * r2
step1   = 1.0 - half_r2
cos_r   = step1 + term
```

```
SIN_C0 = 0xBE2AAAA3   (== -0.16666655242443085, r^3 coefficient)
SIN_C1 = 0x3C08839E   (== 0.008332161232829094, r^5 coefficient)
SIN_C2 = 0xB94CA1F9   (== -0.00019515295571181923, r^7 coefficient)

COS_C0 = 0x3D2AAAA5   (== 0.04166664555668831, r^4 coefficient)
COS_C1 = 0xBAB6061A   (== -0.0013887316454201937, r^6 coefficient)
COS_C2 = 0x37CCF5CE   (== 2.44331567955669e-05, r^8 coefficient)
```

**Quadrant sign/swap** (standard `sin(k·π/2 + r)`/`cos(k·π/2 + r)`
identities for `k mod 4 ∈ {0,1,2,3}`):

```
quadrant = 0: sin(x) = sin_r         cos(x) = cos_r
quadrant = 1: sin(x) = cos_r         cos(x) = -sin_r
quadrant = 2: sin(x) = -sin_r        cos(x) = -cos_r
quadrant = 3: sin(x) = -cos_r        cos(x) = sin_r
```

**Determinism**: identical argument to v0.3's (§6.3 history above,
`docs/E15m_PREREG.md`) — every reduction op is an exact widening cast, an
IEEE-754-mandatory correctly-rounded f64 arithmetic operation,
`f64::round()` (deterministic bit-pattern function), or a single
correctly-rounded narrowing cast; the polynomial evaluation is ordinary
strict-left-to-right f32 arithmetic, no FMA, no reassociation.

**Accuracy** (§6.7's re-measurement): max ULP vs. a correctly-rounded fp32
oracle over the full RoPE position domain (`pos ∈ [0, 8192)`, both pinned
`rope_theta` values) is now **≤2 ULP** (measured max 1.5 ULP on a dense
grid, `scripts/h2m_accuracy_harness.py`), closing the accuracy bar this
task pre-registered and v0.3 (Taylor-polynomial-only fix) missed.

### 6.4 SiLU

```
silu(x) = x / (1.0 + exp_pinned(-x))
```
i.e.: `neg = -x`; `e = exp_pinned(neg)`; `denom = 1.0 + e` (separate add);
`return x / denom` (one IEEE-754-mandatory-correctly-rounded division, not
a reciprocal-multiply).

### 6.5 ln — route (b), pinned Cephes-pattern polynomial (NEW in v0.2, closes v0.1 §14.1)

For `x` a finite `f32`, `x >= 0`:

1. If `x` is NaN or `x < 0.0`, return NaN.
2. If `x == 0.0`, return `-Infinity`.
3. **Exact frexp** (`frexp_exact`, §6.5.1): split `x = m · 2^e`, `m ∈
   [0.5, 1.0)`, via bit manipulation only (no rounding, no library call).
4. Mantissa range fix-up (strict, no FMA):
   ```
   if m < LOG_SQRTHF:      # m < sqrt(0.5)
       e = e - 1
       m = m + m - 1.0      # m := 2m - 1
   else:
       m = m - 1.0
   ```
5. Polynomial evaluation (Horner, strict left-to-right, ascending-then-
   folded per the Cephes logf structure, no FMA):
   ```
   z    = m * m
   poly = LOG_P[0]
   for i in 1..=8:
       poly = poly * m + LOG_P[i]
   y      = poly * m           # y := poly(m) * m
   y      = y * z
   fe     = e as f32            # exact integer->f32 cast (e is small, always exact)
   t1     = fe * LOG_Q1
   y      = y + t1
   half_z = 0.5 * z
   y      = y - half_z
   result = m + y
   t2     = fe * LOG_Q2
   result = result + t2
   ```
   (This computes `ln(x) = ln(m) + e·ln(2)`, with `ln(m)` via the degree-9
   Cephes polynomial `m + m·z·P(m) - z/2` and `e·ln(2)` split as
   `e·LOG_Q1 + e·LOG_Q2` — the same two-part-ln(2) split pattern as
   `EXP_C1`/`EXP_C2`, deliberately reusing identical bit patterns: `LOG_Q1
   == EXP_C2`, `LOG_Q2 == EXP_C1`.)

Pinned coefficients (`f32` bit patterns, hex):

```
LOG_SQRTHF = 0x3F3504F3   (sqrt(0.5))
LOG_Q1     = 0xB95E8083   (ln2 lo, negative — identical bits to EXP_C2)
LOG_Q2     = 0x3F318000   (ln2 hi — identical bits to EXP_C1)
LOG_P[0]   = 0x3D9021BB
LOG_P[1]   = 0xBDEBD1B8
LOG_P[2]   = 0x3DEF251B
LOG_P[3]   = 0xBDFE5D4F
LOG_P[4]   = 0x3E11E9BF
LOG_P[5]   = 0xBE2AAE50
LOG_P[6]   = 0x3E4CCEAD
LOG_P[7]   = 0xBE7FFFFC
LOG_P[8]   = 0x3EAAAAAA
```

**Which `rope_theta` values are conformant.** This construction is used
exactly once per model load, on exactly one input (`ln_pinned(rope_theta as
f32)`, §7.1) — it is not a per-decode-step hot path. It has been validated
(unit test, ≤2e-6 relative tolerance against host `f64::ln` cast down, §6.5
citing `src/math.rs` `ln_matches_std_within_tolerance`) at `x ∈ {0.001, 0.1,
0.5, 0.999, 1.0, 1.5, 2.0, 10.0, 100.0, 100_000.0, 1_000_000.0}`. The two
values that matter for this spec's actual pinned models are
`rope_theta = 100_000.0` (SmolLM2-135M, §13's pinned test vector) and
`rope_theta = 1_000_000.0` (Qwen2.5-0.5B, §0's informative second-model
evidence, `docs/E15d_bc_RESULT.md`); **both are conformant** under this
tolerance. This spec does **not** claim `ln_pinned` is correctly rounded or
bit-exact against any oracle for arbitrary `x` outside the tested set above
— a clean-room implementer targeting a `rope_theta` not in that set should
not assume accuracy without its own validation (carried-forward caution,
same spirit as v0.1 §14.4 for `sin`/`cos`).

#### 6.5.1 `frexp_exact(x)` — exact mantissa/exponent split

```
bits     = x.to_bits()
exp_bits = (bits >> 23) & 0xFF                      # 8-bit biased exponent field, as i32
mantissa_bits = (bits & 0x807FFFFF) | (126 << 23)   # force exponent field to 126 (bias 127-1)
mantissa = f32::from_bits(mantissa_bits)             # in [0.5, 1.0)
exponent = exp_bits - 126
return (mantissa, exponent)
```
Exact (bit reinterpretation only, no rounding), matching §6.2.1's
`ldexp_exact` in spirit (the inverse bit-field operation). Precondition:
`x > 0.0` and finite (checked by the domain guard in step 1–2 above before
this is called).

### 6.6 Table digest (NOW BOUND into the witness chain — see §12.1, closes v0.1 §14.3; CHANGED in v0.3b)

SHA-256 over the LE bytes of every pinned coefficient above, in this exact
declared order — `[EXP_LOG2E, EXP_C1, EXP_C2]`, then `EXP_P[0..6]`, then
**(changed in v0.3b)** `PI_2_F64` (8 little-endian bytes of the `f64` bit
pattern, replacing v0.3's `TWO_PI_F64` and, before that, v0.2's two 4-byte
`f32` half-constants `[TWO_PI_HI, TWO_PI_LO]`), then `SIN_C0`, `SIN_C1`,
`SIN_C2` (replacing v0.2/v0.3's `SIN_COEF[0..11]`), then `COS_C0`,
`COS_C1`, `COS_C2` (replacing `COS_COEF[0..11]`), then `LOG_SQRTHF`, then
`LOG_Q1`, then `LOG_Q2`, then `LOG_P[0..9]` (all `f32`, 4 little-endian
bytes each), concatenated, one continuous SHA-256 stream:

```
table_digest = 23c7bfaf5cef0095fd021af2eb1808abb4928bae4219756d86bdac670a06b35d
```

**v0.3 vs v0.3b**: the *set* of constants hashed changed (one 8-byte
`PI_2_F64` plus 6 minimax coefficients replace `TWO_PI_F64` plus the two
11-entry Taylor tables), so this digest differs from v0.3's
`986abc500e...` (and v0.2's `465d358ccd...`) for that reason alone. This
digest remains one of the raw 32-byte inputs folded directly into
`CIS2_REF` — see §12.1 (unchanged from v0.2's binding).

### 6.7 Accuracy characterization (informative; v0.2 addendum, UPDATED in v0.3 then v0.3b — closes the H2 finding)

§6.2–§6.5 pin exact coefficients; §6.2's addendum (originally added in
v0.2) quantifies their error vs. a correctly-rounded fp32 reference. **v0.3
re-ran this characterization after §6.3's f64-staged reduction fix and
found the fixed degree-10 Taylor polynomial's own truncation error now
dominant (up to ~2813 raw ULP / 486 ULP filtered away from zero
crossings) — a PARTIAL result, missing this task's pre-registered ≤2-ULP
bar. v0.3b (octant reduction + separate minimax polynomials, §6.3) closes
that gap.** Full method, oracle, and domain derivation in
`docs/H2_TRANSCENDENTAL_RIGOR.md` (v0.2 finding) and
`docs/E15m_RESULT.md` (v0.3 partial result + v0.3b resolution).
`exp_pinned`/`ln_pinned`/`rsqrt_cr` are unchanged from v0.2 (their code did
not change); `sin_pinned`/`cos_pinned` are re-measured below, over the full
`pos ∈ [0, 8192)` domain (v0.2's table only covered `pos ≤ 19`):

| function | domain measured | max ULP vs. correctly-rounded fp32 | max relative error |
|---|---|---|---|
| `rsqrt_cr` | all finite x>0 | 0 (correctly rounded by construction) | 0 |
| `exp_pinned` | x∈[-40,40] | 1 | 1.19e-7 |
| `ln_pinned` | x = rope_theta only | 0 at the two pinned values (100000.0, 1000000.0); ≤1 over a padded scan | 0 / 7.85e-8 |
| `sin_pinned` (v0.3, Taylor, informative/superseded) | RoPE angle, pos ∈ [0, 8192) | up to 2813.5 raw (486.5 filtered) | 2.37e-4 |
| `sin_pinned` (v0.3b, minimax, NORMATIVE) | same | **≤1.5** | **1.2e-7** |
| `cos_pinned` (v0.3, Taylor, informative/superseded) | same | up to 407 raw (144.5 filtered) | 3.14e-5 |
| `cos_pinned` (v0.3b, minimax, NORMATIVE) | same | **≤1.5** | **1.2e-7** |

**Resolution**: `docs/E15m_PREREG.md`/`docs/E15m_RESULT.md` document both
the f64-staging fix (v0.3, partial) and the octant-reduction +
minimax-polynomial fix (v0.3b, closes the bar) and their shared
cross-ISA determinism justification (both stages are f64-staged
identically; only the reduction period and the polynomial degree/domain
differ). `table_digest` (§6.6) changed at each step; `inv_freq_table_digest`
(§7.2) never changed (RoPE's `inv_freq` construction only calls
`ln_pinned`/`exp_pinned`, neither of which changed at any point in this
task). This closes the "if decode length were ever extended toward
`max_position_embeddings = 8192`" caveat v0.2 §6.7 flagged for future
work — v0.3b measures that full range directly and meets a ≤2-ULP bar
across it, rather than extrapolating from `pos ≤ 19`.

## 7. RoPE (normative, now theta-general — closes v0.1 §14.1)

7.1. **`inv_freq` construction.** For `i = 0..head_dim/2` (32 values for
SmolLM2-135M's `head_dim = 64`; a different `head_dim` scales this
identically):

```
ln_theta = ln_pinned(rope_theta as f32)          # §6.5, NEW: general, not a literal
for i in 0..head_dim/2:
    frac    = (2*i as f32) / (head_dim as f32)     # e.g. i=0 -> 0.0, i=1 -> 2/64
    neg_arg = -(frac * ln_theta)                    # separate mul, then negate
    inv_freq[i] = exp_pinned(neg_arg)                # §6.2, the SAME pinned exp
```

**v0.1 vs v0.2**: v0.1 pinned `LN_THETA` as a bare literal f32 bit pattern
(`0x413834F1`) valid **only** for `rope_theta == 100000.0`, and mandated the
loader assert this exact value and refuse to run otherwise (v0.1 §2.4).
v0.2 **removes that restriction**: `ln_theta` is computed at load time from
whatever `rope_theta` is present in `config.json`, via the pinned `ln`
polynomial (§6.5) — not any host `pow`/`powf`/`ln` call. For
`rope_theta = 100000.0` specifically, `ln_pinned(100_000.0)` MUST agree with
the old v0.1 literal `0x413834F1` to within the same ≤2e-6 relative
tolerance used elsewhere in this spec (it is not required to be bit-
identical to the old hardcoded literal, since the literal was the
RNE-nearest f32 to the true `ln(100000)` while `ln_pinned` is a polynomial
approximation — the two need not collide at the last bit; what matters is
that `inv_freq_table_digest`, §7.2, still reproduces bit-for-bit run-to-run
and cross-ISA, which it does, §13.1).

Mathematically this is still `inv_freq[i] = theta^(-2i/head_dim) =
exp(-(2i/head_dim)·ln(theta))`, evaluated with the pinned `exp_pinned`
polynomial (§6.2) and now also the pinned `ln_pinned` polynomial (§6.5)
rather than any host `pow`/`powf`/`ln` call — this is a deliberate, pinned
choice (superseding both the v0.1 literal draft and an earlier,
non-normative pre-v0.1 draft that used host `f64::powf`; see Appendix A for
the exact history).

7.2. **`inv_freq` table digest.** SHA-256 over the LE bytes of each of the
`head_dim/2` `inv_freq` values, `f32.to_le_bytes()`, in index order, one
continuous stream. **Unchanged construction from v0.1** (this digest was
already raw bytes, not hex-ASCII, in v0.1 — see §14.2 (v0.1 numbering) /
Appendix B item 3). For SmolLM2-135M (`head_dim=64`, `rope_theta=100000.0`,
32 values):

```
inv_freq_table_digest = da9f6dcfde0425588815509e874515cdcd3d6b8818b6d0136590052e7bbf6f12
```

Identical bit-for-bit to v0.1's value for this same model — evidence that
switching from the bare `LN_THETA` literal to the general `ln_pinned(rope_theta)`
call did not change SmolLM2-135M's `inv_freq` table at all (§16 changelog
note). **Now bound into `CIS2_REF`** (§12.1) — v0.1 computed and printed
this digest but never fed it into the witness chain (v0.1 §14.3); v0.2
closes that gap.

7.3. **Per-position cos/sin table.** For a query/key head being rotated
at sequence position `pos` (a `usize`, cast to `f32` exactly — `pos` never
exceeds 19 in this spec's fixed 20-position decode, well within `f32`'s
exact-integer range):

```
for i in 0..half (half = head_dim/2 = 32):
    angle    = (pos as f32) * inv_freq[i]
    cos_v[i] = cos_pinned(angle)     # §6.3
    sin_v[i] = sin_pinned(angle)     # §6.3
```

7.4. **Rotation (rotate-half convention, `rope_interleaved = false`).**
Given a `head_dim`-length slice `head[0..head_dim]` for one attention
head, with `half = head_dim/2`:

```
for i in 0..half:
    x1 = head[i]
    x2 = head[i + half]
    t1 = x1 * cos_v[i]
    t2 = (-x2) * sin_v[i]
    out[i]        = t1 + t2
    t3 = x2 * cos_v[i]
    t4 = x1 * sin_v[i]
    out[i + half] = t3 + t4
head[0..head_dim] = out[0..head_dim]   # in place, after computing all `out`
```

This is applied to **every** query head (9 heads, each `head_dim=64`
slice of the 576-wide `q` vector) and **every** key head (3 heads, each
`head_dim=64` slice of the 192-wide `k` vector) independently, once per
decode step, at that step's `pos`. Values are never rotated more than
once (the KV cache stores post-RoPE `k`; §3.5).

## 8. RMSNorm (normative)

**Unchanged from v0.1** (verbatim):

For input vector `x` of length `n = hidden = 576`, gain vector `weight`
of the same length, and `eps` = `EPS_F32` (§2.3):

```
for i in 0..n: sq[i] = x[i] * x[i]
ss   = sum_seq(sq)              # §5.3, strict left-to-right
mean = ss / (n as f32)          # one IEEE-754 division
inv  = rsqrt(mean + eps)        # §6.1: 1.0 / (mean+eps).sqrt()
for i in 0..n:
    scaled = x[i] * inv
    out[i] = scaled * weight[i]     # (x[i]*inv)*weight[i] — THIS association, not x[i]*(inv*weight[i])
```

The multiply order `(x[i] * inv) * weight[i]` (not `x[i] * (inv *
weight[i])`) is pinned explicitly: floating-point multiplication is not
associative under rounding, so these two orders can differ in the low bit
in general, even though no divergence from this specific reordering has
been observed on this model/prompt.

Applied twice per layer (`input_layernorm` before attention, in §2.5's
naming `post_attention_layernorm` before the MLP) and once after the final
layer (`model.norm.weight`), all using the same procedure and the same
`eps`.

## 9. Attention (GQA, causal, per decode step) (normative)

Let `qh` range over `n_heads = 9` query heads, `kv_head = qh /
group` (`group = 3`) map each query head to its shared KV head (integer
division), `head_dim = 64`.

9.1. **Projections.** `q = matvec(q_proj, ln1, 576, 576)`; `k =
matvec(k_proj, ln1, 192, 576)`; `v = matvec(v_proj, ln1, 192, 576)`
(§5.2), where `ln1` is this layer's post-RMSNorm hidden state (§8).
**New in v0.2 (informative for SmolLM2-135M, normative for any checkpoint
that carries these tensors)**: if the checkpoint provides
`self_attn.{q,k,v}_proj.bias` tensors (Qwen2-family
`attention_bias=true`), each is added elementwise (§5.4) to the
corresponding projection immediately after the matvec, before RoPE; if the
checkpoint has no such tensors (Llama-family, including SmolLM2-135M),
this step is a no-op and the pinned §13 test vector is unaffected. RoPE
(§7) is then applied in place to each of the 9 query-head slices of `q`
and each of the 3 key-head slices of `k`, at the current step's `pos`. `v`
is never rotated.

9.2. **Score.** For query head `qh` at position `pos`, against every
cached key position `j = 0..=pos` (causal: only positions ≤ current,
enforced by the KV cache containing exactly those positions, not by an
explicit mask value):

```
scale     = rsqrt(head_dim as f32)     # computed once: rsqrt(64.0) == 0.125 exactly
d         = dot_seq(q_head, k_j)        # §5.1, over the 64-dim head slice
scores[j] = d * scale                    # separate multiply, applied AFTER the dot
```

9.3. **Softmax** (`softmax_seq`, in place over `scores[0..=pos]`):

```
max_v = scores[0]
for v in scores[1..]:
    if v > max_v: max_v = v      # strict >, so the FIRST occurrence of the max wins ties
for v in scores: v = exp_pinned(v - max_v)     # §6.2
denom = sum_seq(scores)           # §5.3
for v in scores: v = v / denom     # elementwise division, NOT multiply-by-reciprocal
```

9.4. **V-mix.** For each output dimension `d = 0..head_dim`:

```
acc = 0.0_f32
for j in 0..=pos:
    p   = scores[j] * v_cache[j][kv_head][d]
    acc = acc + p                                # separate mul, separate add — same
                                                   # left-to-right order as §5.1, written
                                                   # as an explicit loop rather than a
                                                   # dot_seq call, but semantically identical
out_head[d] = acc
```

9.5. **Output projection and residual.** Concatenate all 9 `out_head`
slices into a 576-wide `attn_out`; `o = matvec(o_proj, attn_out, 576,
576)`; `h = elementwise_add(h, o)` (§5.4).

## 10. MLP / SwiGLU (normative)

**Unchanged from v0.1** (verbatim):

Given this layer's post-`post_attention_layernorm` hidden state `ln2`
(576-wide):

```
gate = matvec(gate_proj, ln2, 1536, 576)     # §5.2
up   = matvec(up_proj,   ln2, 1536, 576)
for i in 0..1536:
    hid[i] = silu_pinned(gate[i]) * up[i]     # §6.4, then one separate multiply
down = matvec(down_proj, hid, 576, 1536)
h    = elementwise_add(h, down)                # §5.4
```

## 11. LM head and argmax (normative)

11.1. After the final layer, `hn = rmsnorm(h, model.norm.weight, eps)`
(§8). `logits = matvec(lm_head_weights, hn, vocab, hidden)` (§5.2). For
SmolLM2-135M (`tie_word_embeddings=true`), `lm_head_weights` is the tied
`embed_tokens.weight` matrix directly (§2.5) — no separate weight, no
transpose (the embedding table is already `[vocab, hidden]`, the exact
shape a `matvec` row-dot needs). **New in v0.2 (informative for
SmolLM2-135M, normative for any checkpoint with
`tie_word_embeddings=false`)**: if the checkpoint config sets
`tie_word_embeddings=false` and provides a separate `lm_head.weight`
tensor (`[vocab, hidden]`), that tensor is used instead of `embed_tokens`;
this branch is untested by this version's pinned §13 test vector
(SmolLM2-135M is tied) but is exercised by the informative Qwen2.5-0.5B
evidence (§0), which is itself tied (`tie_word_embeddings=true` for the
base, non-Instruct checkpoint) — so even that evidence does not exercise
the untied branch end-to-end; a clean-room implementer targeting an
untied checkpoint should treat this branch as spec-described but
less-validated than the tied path.

11.2. **Argmax**, strict left-to-right scan, first-occurrence-wins on
exact ties:

```
best_idx = 0
best_val = logits[0]
for idx, v in enumerate(logits):
    if v > best_val:          # strict >, never >=
        best_val = v
        best_idx = idx
next_token_id = best_idx as u32
```

## 12. Digest / receipt format (normative)

All digests are SHA-256 (32 raw bytes), rendered as lowercase hex (64
ASCII characters) **only for display/printing** — the witness chain itself
consumes raw bytes, not the hex rendering (§12.1, this is the v0.2 change
from v0.1). There are **three separate, independently computed** digests;
none of them contains any of the others as a sub-input except where
explicitly stated.

12.1. **Witness chain / `CIS2_REF` digest.** One continuous
`Sha256::update()` stream (not a step-wise re-hash of
`running_digest || new_data` — this is a single hash object updated
repeatedly, then finalized once), fed in exactly this order:

1. `weights_sha256` — the **raw 32-byte SHA-256 digest** of
   `model.safetensors` (§2.1). **CHANGED in v0.2**: v0.1 fed the
   **64-character lowercase hex ASCII string** (the digest's UTF-8/ASCII
   bytes, 64 bytes) instead of these 32 raw bytes; this closes v0.1 §14.2.
2. `tokenizer_sha256` — same raw-32-byte encoding, `tokenizer.json`'s
   digest.
3. `config_sha256` — same raw-32-byte encoding, `config.json`'s digest.
4. `table_digest` — the **raw 32 bytes** of §6.6's pinned
   exp/sin/cos/ln coefficient-table digest. **NEW in v0.2** (closes v0.1
   §14.3): v0.1 computed and printed this value but never fed it into the
   witness chain.
5. `inv_freq_table_digest` — the **raw 32 bytes** of §7.2's RoPE
   `inv_freq` table digest. **NEW in v0.2** (closes v0.1 §14.3, same gap
   as item 1).

   **E15k correction (this pass):** this doc previously listed items
   1-5 in the order table_digest, inv_freq_table_digest, weights,
   tokenizer, config. That prose never matched the actual reference
   implementation (`src/main.rs`, which is the source of the pinned
   `CIS2_REF=a0c563ef...` value below) — the reference feeds
   weights/tokenizer/config first, then table/inv_freq, as corrected
   above. A from-spec-text-only clean-room (`verify3/`, E15j) followed
   the old (wrong) prose exactly and reproduced every other digest
   bit-for-bit (`table_digest`, `inv_freq_table_digest`, `argmax_digest`,
   all 16 `generated_token_ids`) but got a different `CIS2_REF`
   (`a532d4a4...`) purely from this item-order mismatch — see
   `docs/E15k_DIVERGENCE_LOCALIZATION.md`. Fixed here; `verify3/model.c`
   corrected to match and reconfirmed bit-exact on all 4 CI cells
   (x86_64/aarch64 × gcc/clang).
6. Every prompt token id, in order, each as **`u32` little-endian, 4
   bytes** (`t.to_le_bytes()`) — 4 tokens × 4 bytes = 16 bytes total for
   this prompt. **Unchanged from v0.1.**
7. For each of the `gen_toks` decode steps (16 for the pinned §13 test
   vector), in step order (`step = 0..gen_toks`):
   a. The **full fp32 logit vector for this step** (49152 entries for
      SmolLM2-135M, in vocab-index order), each entry's raw bit pattern as
      `u32` little-endian (`v.to_bits().to_le_bytes()`), concatenated —
      49152 × 4 = 196608 bytes per step for this vocab size. This is the
      logit vector **before** this step's argmax pick (i.e., the vector
      argmax was just computed against), not the vector for the *next*
      position. **Unchanged from v0.1.**
   b. The chosen `next_token_id` for this step, as **`u32` little-endian,
      4 bytes**. **Unchanged from v0.1.**

Finalize once after all steps; the resulting 32-byte digest, hex encoded,
is `CIS2_REF`. For the pinned SmolLM2-135M / `"Once upon a time"` /
16-token test vector:

```
CIS2_REF = d82743059d1db929e710236fe4ec37f89e6f932524801345a006980f7c3cc9df
```

printed as `CIS2_REF digest=d8274305... prompt_idx=0 prompt_toks=4
gen_toks=16 dtype=fp32`. **This digest is not backward-compatible with
v0.3's `90f7484e...`, v0.2's `a0c563ef...`, or v0.1's `ba88708bf4...`** —
v0.3b changed `table_digest` (§6.6, the octant-reduction constant plus 6
minimax coefficients replacing v0.3's single f64 reduction constant plus
the two Taylor tables), which feeds directly into this witness chain (item
4 below); v0.2→v0.3 separately changed `table_digest`'s constant set (f64
reduction constant replacing two f32 halves); the v0.1→v0.2 transition
changed the item order and the item 3–5 encoding (raw bytes, not
hex-ASCII); see §16 for the full breakdown of which change contributed
how. `generated_token_ids` and `argmax_digest` for this 16-token pinned
test vector are **unchanged from v0.1/v0.2/v0.3** (none of this task's
`sin`/`cos` accuracy fixes are large enough at `pos ≤ 19` to flip any of
the 16 greedy argmax decisions — see `docs/E15m_RESULT.md`).

12.2. **Argmax-token digest.** **Unchanged construction and unchanged
value from v0.1** (this digest was never affected by either v0.2 change —
it does not touch `table_digest`, `inv_freq_table_digest`, or any artifact
hash). A **separate** `Sha256` instance (not derived from or continuing
the witness chain above), fed the LE `u32` bytes of every token id in
`prompt_token_ids ++ [16 generated token ids]` (20 tokens total, in that
order, prompt first), one continuous stream, finalized once:

```
argmax_digest = 0b9c8f3ac90d0b9cd5f1719ac327dca1fc639fd87468305fccebbe3d56f67aff
```

12.3. **Table digests** (§6.6, §7.2) are now **inputs to** `CIS2_REF`
(§12.1 items 1–2, new in v0.2) but remain independent of, and not inputs
to, the argmax-token digest (§12.2) — printed separately as before, in
addition to being folded into the witness chain.

12.4. **Determinism check (MUST).** The reference computes the entire
decode (§3.4) **twice** in the same process (`run1`, `run2`) and MUST
assert all three of: `witness_digest_run1 == witness_digest_run2`,
`argmax_digest_run1 == argmax_digest_run2`, and
`token_ids_run1 == token_ids_run2`, before printing any result — this is
the same-host determinism bar, a precondition for the stronger cross-ISA
claim (§13.2), not itself the interesting claim. **Unchanged from v0.1.**

## 13. Test vectors (normative)

13.1. **Full run, prompt `"Once upon a time"`, 16 greedy tokens:**

```
weights_sha256   = 80521b40281d6ce74e35c9282c22539e75aa0ac8578892b2a59955ef78d55da1
config_sha256    = 1d556eab73b69c7f11f64c557a2f9c6f440bd4c6b89bb2584a6b498c92603843
tokenizer_sha256 = 9ca9acddb6525a194ec8ac7a87f24fbba7232a9a15ffa1af0c1224fcd888e47c
prompt_token_ids = [6403, 1980, 253, 655]
generated_token_ids (16, in order) =
    [28, 665, 436, 253, 1838, 8180, 3365, 14176, 30, 2306, 4161, 281, 253, 2066, 2291, 351]
table_digest           = 23c7bfaf5cef0095fd021af2eb1808abb4928bae4219756d86bdac670a06b35d
inv_freq_table_digest  = da9f6dcfde0425588815509e874515cdcd3d6b8818b6d0136590052e7bbf6f12
argmax_digest          = 0b9c8f3ac90d0b9cd5f1719ac327dca1fc639fd87468305fccebbe3d56f67aff
CIS2_REF (witness_digest) = d82743059d1db929e710236fe4ec37f89e6f932524801345a006980f7c3cc9df
```

Note `generated_token_ids` and `argmax_digest` are **unchanged from v0.3,
v0.2, and v0.1** — none of v0.2's, v0.3's, or v0.3b's changes altered the actual
computed logits or greedy decisions at this 16-token/pos≤19 length, only
the receipt's hashing (v0.2, §16) or the reduction's accuracy at longer
positions than this pinned vector exercises (v0.3, §6.3/§6.7).

13.2. **Cross-run/cross-ISA conformance bar.** All of §13.1's values MUST
reproduce bit-for-bit: (a) across two sequential runs in the same process
(§12.4); (b) across two separate OS process invocations on the same host;
(c) across x86-64 and aarch64, same source, unmodified, both with §1.3's
FTZ/DAZ pin actually in effect (verified by the adversarial self-test,
§1.3) and §1.4's zero-FMA gate passing (disassembly check). **Unchanged
requirement from v0.1**, now additionally exercised by §13.4's 20-cell
compiler-invariance matrix.

13.3. **Step-0 full-logit-vector spot check (informative, not part of
`CIS2_REF`)**: an independent oracle comparison
(`docs/E15b_m1p5_CORRECTNESS.md`) against `torch`/`transformers` fp32
forward pass of the same checkpoint found, at generation step 0 (right
after prefill, before the first generated token), across all 49152
logits: `max_abs_diff ≈ 8.965e-05` (vocab index 40082: this reference
`5.486028671264648`, oracle `5.486118316650391`), `max|logit| ≈
22.531156539916992`, relative diff `≈ 3.98e-06` — evidence of
*correctness* (this is a valid forward pass), not evidence of bit-identity
with `torch` (which this spec never claims; `torch` uses its own BLAS
reduction order and libm, out of scope). This spec does not define a
`--dump-step0` flag as part of its normative surface; the debug env-var
hook (`CIS2_DUMP_STEP0_LOGITS`, Appendix A) that produced this comparison
is informative tooling, not part of conformance. **Unchanged from v0.1.**
A second, independently-run oracle comparison against Qwen2.5-0.5B
(`docs/E15d_bc_RESULT.md`, greedy 16/16 token match, logit relative
diff ≈4.4e-6) is informative evidence for §7's theta-general RoPE, not a
§13.1 test vector.

13.4. **Compiler-invariance matrix (NEW in v0.2, informative but
strongly evidential)**: the pinned SmolLM2-135M test vector's `CIS2_REF`
and `inv_freq_table_digest` reproduce bit-for-bit across a 20-cell matrix
of `{x86_64, aarch64} × {opt-level 0,1,2,3,s} × {target-cpu generic,
native}`, with zero FMA instructions in every cell's disassembly (§1.4).
Preregistered digest values and the full per-cell table are recorded in
`docs/E15d_v0.2_DIGESTS.md` (this branch); the v0.1-era version of this
same check (`docs/E15d_a_COMPILER_INVARIANCE.md`) targeted the old
`ba88708b...` digest and is superseded by the v0.2 rerun.

## 14. Known gaps and internal inconsistencies (informative — read before treating this as complete)

Renumbered from v0.1's §14; items resolved by v0.2 are marked **CLOSED**
and kept for history, per §16's changelog discipline.

14.1. **`ln_pinned`'s validated domain is a finite, explicitly-tested set
of `x` values (§6.5), not a general accuracy proof.** The two values that
matter for this spec's models (`100_000.0`, `1_000_000.0`) are both
tested to ≤2e-6 relative tolerance against host `f64::ln` cast to f32; a
`rope_theta` far outside the tested range (e.g. `< 0.001` or a value
requiring `frexp_exact`'s domain guard to reject NaN/negative inputs) is
unvalidated by this document. This is the direct successor to v0.1's
"§14.1: rope_theta=100000.0-only" gap — **PARTIALLY CLOSED**: the
literal-only restriction is gone, but "pinned for exactly one theta" has
been replaced by "validated for a finite tested set of thetas," which is
weaker than "proven general" but strictly broader than v0.1's single-value
pin.

14.2. **Digest byte encoding for artifact hashes: CLOSED.** v0.1 fed the
64-character hex **string's** ASCII bytes into the witness hash, not the
32 raw digest bytes — an ambiguity only recoverable by reading
`src/main.rs`'s `sha256_file` return type. v0.2's `sha256_file` now
returns `[u8; 32]` directly (Appendix A), and the witness chain (§12.1)
consumes those raw bytes; hex encoding is applied only at print time via a
local `hex::encode` helper. Closed by construction, not by convention —
there is no longer a hex `String` in the artifact-hash code path for the
witness chain to accidentally consume.

14.3. **Table digests not bound into `CIS2_REF`: CLOSED.** v0.1's
`table_digest` and `inv_freq_table_digest` were computed and printed
entirely independently of the witness chain — a receipt holder could not
detect, from `CIS2_REF` alone, whether a verifier used the exact pinned
polynomial/RoPE-table coefficients of §6/§7 or some other transcendental
implementation producing the same logits. v0.2 folds both digests into
the witness chain's seed (§12.1 items 1–2), ahead of the artifact hashes.
**Residual caveat**: this closes the "not bound at all" gap, but a
`CIS2_REF` mismatch still does not, by itself, tell a verifier *which* of
the now-five seed inputs (2 table digests + 3 artifact hashes) diverged —
a verifier wanting to localize a mismatch should still compare
`table_digest`/`inv_freq_table_digest`/artifact hashes individually (all
five are still printed, §12.3), not rely on `CIS2_REF` alone to diagnose
*why* it differs.

14.4. **Trig polynomial accuracy is only validated for `|x| ≲ 14`** (unit
tests sweep `x = i * 0.7` for `i` in `-20..=20`). RoPE angles in this
spec's fixed 20-position decode stay small (`pos < 20`, `inv_freq ≤ 1.0`
for `rope_theta=100000`; for `rope_theta=1000000`, `inv_freq` values are
smaller still, since `inv_freq[i] = theta^(-2i/64)` shrinks faster for
larger theta at fixed `i`, so angles stay in-range there too), so this is
adequate for §13's test vectors, but the two-part-π reduction (§6.3) has
not been stress-tested at larger magnitudes where it could lose more
precision. A clean-room implementer targeting a longer sequence than this
spec's 20 positions should not assume this polynomial's accuracy holds
unchanged. **Unchanged from v0.1 (was §14.4 there too).**

14.5. **RMSNorm multiply order (§8) is pinned but its bit-level necessity
is unconfirmed.** `(x[i]*inv)*weight[i]` vs. `x[i]*(inv*weight[i])` are
not provably identical for arbitrary fp32 operands under rounding, but no
divergence between the two orders has actually been observed on either
model tested. **Unchanged from v0.1 (was §14.5 there too).**

14.6. **The oracle correctness checks (§13.3) are defensible spot-checks,
not exhaustive.** They confirm greedy token-id agreement and one step's
full-vocab logit agreement to ~4e-6 relative on two model families now
(SmolLM2-135M, Qwen2.5-0.5B) — neither checks every intermediate layer's
activations against the oracle, so a compensating pair of errors elsewhere
in the layer stack that happens to preserve step-0's output and all
argmax decisions cannot be completely ruled out by this evidence alone.
**Unchanged in kind from v0.1 (was §14.6 there); now covers two models
instead of one.**

14.7. **This spec's own history.** Carried forward from v0.1: earlier
states of the reference computed `inv_freq` via unpinned host `f64::powf`,
producing a *different* `CIS2_REF`
(`830d972dbfb0b5598015f33571d08623d2b05d8e239b8d0288562d9ac9786907`) than
v0.1's `ba88708b...` (produced after switching to `exp_pinned`-based
`inv_freq`). v0.2 adds a third data point:
`a0c563ef804f50413b7fb6619ae4afe9b51b1ffa7655e944221393e85d6261da`
(§13.1, this document), produced after (a) generalizing `inv_freq` to any
`rope_theta` via `ln_pinned` and (b) the two receipt-format changes
(§12.1). The `argmax_digest` (`0b9c8f3a...`) has been unchanged across
*all three* `CIS2_REF` states — the greedy token ids have never flipped
across any of these reference-internal changes, only the full logit/receipt
bit patterns did. This is recorded here because it demonstrates, a second
time, the exact failure mode §14.3 (now closed) used to warn about: a
`CIS2_REF`-only comparison cannot localize *which* internal change moved
the digest without also comparing the finer-grained digests
individually.

## 15. Conformance (normative)

An implementation is CIS-2 v0.2 conforming iff, from this document's text
alone (no access to `src/`):

1. It reproduces every value in §13.1 bit-for-bit, on x86-64.
2. It reproduces every value in §13.1 bit-for-bit, on aarch64, unmodified
   source, with the ISA-specific FTZ/DAZ leg of §1.3 actually exercised
   (not a no-op stub).
3. Its release binary contains zero FMA instructions on the decode path
   (§1.4, disassembly-verified).
4. Its self-test (§1.3's adversarial denormal check) passes.
5. It passes §12.4's same-process two-run determinism check.

This is a narrower and more mechanical bar than CIS-1's three-tier scheme
(CIS-1 §8) because CIS-2 has exactly one pinned (model, prompt, length)
tuple as its normative §13.1 test vector, rather than CIS-1's
op-goldens/selftest/token-digest split; a future version should factor out
op-level goldens (individual
`exp_pinned`/`sin_pinned`/`cos_pinned`/`ln_pinned`/`rsqrt`/`dot_seq` unit
vectors) as their own tier, independent of the full 30-layer decode, the
way CIS-1's Tier 1/Tier 2 do — not done in this version. **Unchanged
structure from v0.1**, item list identical; only the referenced §13.1
values changed underneath it.

## 16. Version history

- **v0.3 (2026-08-29, PARTIAL — superseded by v0.3b below)** — attempted
  to close CIS-2's one remaining stated technical limitation (v0.2 §6.7 /
  `docs/H2_TRANSCENDENTAL_RIGOR.md`): `sin_pinned`/
  `cos_pinned`'s §6.3 range reduction is now staged through `f64` instead
  of two `f32` half-constants, fixing catastrophic-cancellation accuracy
  loss that grew with RoPE position (up to 1104 ULP / 1e-4 relative by
  position 19 in v0.2; ~0.58 relative, unusable, toward position 8192).
  Design pre-registered before implementation in `docs/E15m_PREREG.md`;
  gate results (determinism, accuracy, oracle-correctness) in
  `docs/E15m_RESULT.md`.

  **What changed**: §6.3 (reduction only, not the degree-10 Taylor
  polynomials); §6.6 (`table_digest` now hashes one 8-byte `TWO_PI_F64`
  constant in place of v0.2's two 4-byte `TWO_PI_HI`/`TWO_PI_LO`
  constants); §6.7 (accuracy table re-measured over the full
  `pos ∈ [0, 8192)` domain instead of v0.2's `pos ≤ 19`).

  **What did not change**: §7 (RoPE `inv_freq` construction —
  `ln_pinned`/`exp_pinned` untouched), `inv_freq_table_digest`
  (`da9f6dcfde...`, bit-identical to v0.1/v0.2), `argmax_digest`
  (`0b9c8f3a...`) and `generated_token_ids` for the 16-token/pos≤19 pinned
  test vector (the f64-staged fix is far more accurate at short range but
  not different enough from v0.2's already-adequate short-range values to
  flip any of the 16 greedy decisions at this length).

  **Net effect on test vectors (§13.1)**: `CIS2_REF` changed
  (`a0c563ef80...` → `90f7484e4c...`); `table_digest` changed
  (`465d358ccd...` → `986abc500e...`); `inv_freq_table_digest`,
  `argmax_digest`, `generated_token_ids` unchanged from v0.2.

  Also in this branch: `.github/workflows/e15d-compiler-invariance.yml`
  and `.github/workflows/e15c-cross-isa.yml` `TARGET_DIGEST` updated to
  `90f7484e4c...` (`TARGET_INVFREQ_DIGEST` unchanged); `verify2/` and
  `verify3/` clean-rooms updated from this spec's §6.3 text only (not by
  reading `src/math.rs`), logged in each crate's own `CLEANROOM_LOG.md`;
  new `scripts/h2m_accuracy_harness.py` (mpmath oracle, pos up to 8192);
  `scripts/oracle_compare.py`/`scripts/oracle_compare_qwen.py` extended to
  a 2048-token horizon.

  **PARTIAL result (gate 2 missed)**: the accuracy harness
  (`scripts/h2m_accuracy_harness.py`) found max relative error improved
  ~55-70x (1.30e-2 -> 2.37e-4 sin, 1.36e-2 -> 3.14e-5 cos) but max ULP was
  still up to 2813 (486 filtered away from zero crossings) — the
  pre-registered <=2 ULP bar was NOT met. Root cause: the reduction itself
  became ~exact (matches an arbitrary-precision reduction to ~1 ULP of the
  reduced argument `r`); the *fixed degree-10 Taylor polynomial's own
  truncation error*, worst near `|r| ~ pi` and at sin/cos zero crossings,
  became the dominant term. Reported honestly rather than narrowing the
  claim; superseded by v0.3b below per coordinator directive.

- **v0.3b (2026-08-29)** — closes CIS-2's one remaining stated technical
  limitation, meeting the pre-registered accuracy bar v0.3 missed. Same
  pre-registration (`docs/E15m_PREREG.md`), refined mechanism: §6.3 now
  reduces to an octant (`r ∈ [-pi/4, pi/4]`, quadrant index `k mod 4`,
  still f64-staged, same Cody-Waite pattern and determinism argument as
  v0.3, just mod `pi/2` instead of mod `2*pi`), then evaluates sin(r)/
  cos(r) with SEPARATE degree-7/8 Cephes `sinf`/`cosf` minimax polynomials
  (not Taylor truncations), then selects/signs the result by quadrant.

  **What changed**: §6.3 (reduction period and polynomial, both); §6.6
  (`table_digest` now hashes one 8-byte `PI_2_F64` constant plus 6 pinned
  f32 minimax coefficients — `SIN_C0/C1/C2`, `COS_C0/C1/C2` — in place of
  v0.3's `TWO_PI_F64` plus the two 11-entry Taylor tables); §6.7 (accuracy
  table adds the v0.3b row, marked NORMATIVE, alongside v0.3's superseded
  row for comparison).

  **What did not change**: §7 (RoPE `inv_freq` construction), everything
  else in v0.3's "what did not change" list; `argmax_digest`/
  `generated_token_ids` for the 16-token pinned test vector remain
  unchanged across v0.1/v0.2/v0.3/v0.3b.

  **Net effect on test vectors (§13.1)**: `CIS2_REF` changed
  (`90f7484e4c...` -> `d82743059d...`); `table_digest` changed
  (`986abc500e...` -> `23c7bfaf5c...`); `inv_freq_table_digest`,
  `argmax_digest`, `generated_token_ids` unchanged from v0.3/v0.2/v0.1.

  **Gate (2) result**: `scripts/h2m_accuracy_harness.py` re-run to
  position 8192 on both pinned `rope_theta` values (SmolLM2-135M 1e5,
  Qwen2.5-0.5B 1e6) measures max **1.5 ULP** (both sin and cos, both
  models), max relative error ~1.2e-7 — meets the <=2 ULP bar.

  Also in this branch: `.github/workflows/e15d-compiler-invariance.yml`
  and `.github/workflows/e15c-cross-isa.yml` `TARGET_DIGEST` updated to
  `d82743059d...`; `verify2/`/`verify3/` clean-rooms updated a second time
  from this spec's v0.3b §6.3 text only, logged in each crate's own
  `CLEANROOM_LOG.md`; all three implementations (`cis2_ref`, `verify2`,
  `verify3`) confirmed bit-for-bit matching locally on x86_64
  (`d82743059d...`) — see `docs/E15m_RESULT.md`'s v0.3b section for CI
  run ids (cross-ISA confirmation pending in CI).

- **v0.1 (2026-08-28)** — first draft. Closes every item in
  `verify/SPEC_GAPS.md` (digest byte encoding, transcendental route and
  exact coefficients, RoPE `inv_freq` construction and digest, RMSNorm
  elementwise order) against the actual reference implementation at the
  commit cited in v0.1's Appendix A. Known-incomplete: v0.1 §14's items,
  especially 14.1 (theta-general RoPE) and 14.3 (table digests not bound
  into the receipt), left open for v0.2.

- **v0.2 (2026-08-28)** — three changes, all against `origin/cm/e15h-ref-fixes`
  (Appendix A):
  1. **Table digests folded into `CIS2_REF`** (closes v0.1 §14.3). §12.1
     items 1–2 (new), §6.6/§7.2 (both digests now witness-chain inputs,
     appended AFTER the three artifact hashes: the seeding order is
     weights, tokenizer, config, then table_digest, then
     inv_freq_table_digest — see §12.1 and src/main.rs:555-559.
     [E15k/H3 correction: an earlier draft of this line said "table
     digest first"; that was wrong and never matched the reference.]).
  2. **RoPE `inv_freq` is now theta-general** (closes v0.1 §14.1). New
     §6.5 pinned `ln_pinned` polynomial (Cephes-pattern logf, exact
     `frexp_exact` bit-split, degree-9 Horner in the reduced mantissa);
     §7.1's `LN_THETA` bare literal removed, replaced by
     `ln_pinned(rope_theta as f32)`; §2.4's `rope_theta==100000.0`-only
     assert removed. Validated on SmolLM2-135M (`rope_theta=100000`,
     `inv_freq_table_digest` bit-identical to v0.1) and, informatively,
     Qwen2.5-0.5B (`rope_theta=1000000`, `docs/E15d_bc_RESULT.md`).
  3. **Witness header now feeds raw 32-byte digest bytes, not 64-char
     hex-ASCII strings** (closes v0.1 §14.2/§12.1). `sha256_file()` now
     returns `[u8; 32]`; hex encoding moved to a display-only helper.

  **Net effect on test vectors (§13.1)**: `CIS2_REF` changed
  (`ba88708bf4...` → `a0c563ef80...`); `table_digest` changed
  (`0bf9257bc5...` → `465d358ccd...`, because the coefficient set it
  covers grew to include the new `ln` table — not because of the raw-bytes
  change, which affects `CIS2_REF`'s artifact-hash inputs, not
  `table_digest`'s own internal computation); `inv_freq_table_digest`
  **unchanged** (`da9f6dcfde...`, both because its own construction was
  already raw-bytes in v0.1 and because `ln_pinned(100000.0)` reproduces
  the same `inv_freq` values `LN_THETA`'s literal did, to the precision
  that matters); `argmax_digest` and `generated_token_ids` **unchanged**
  (`0b9c8f3a...`; none of the three v0.2 changes touch what the model
  actually computes, only how the receipt hashes it).

  Also in this branch (not spec content, but shipped alongside v0.2):
  the E15d(a) compiler-invariance workflow's pre-registered target updated
  from v0.1's `ba88708b...` to v0.2's `a0c563ef...`
  (`.github/workflows/e15d-compiler-invariance.yml`); a fresh
  20-cell-matrix rerun and the E15d(b)/E15d(c) cross-ISA reruns against
  this v0.2 reference are recorded in `docs/E15d_v0.2_DIGESTS.md`.

- **v0.2.1 (2026-08-28, H4)** — doc-only, no digest change. Closes H3
  BLOCKER-2 (`docs/H3_SPEC_AUDIT.md`; carried forward from
  `verify3/SPEC_GAPS_v0.2.md` items 1–2): §3.1 is fully rewritten from a
  one-paragraph "HuggingFace `tokenizers`-format, BPE-family" pointer into
  a self-contained byte-level BPE specification — exact byte→unicode map
  construction, the literal GPT-2/ByteLevel pretokenizer regex plus the
  `Digits(individual_digits=true)` pre-split this checkpoint's
  `tokenizer.json` actually configures, the rank-ordered/leftmost-tie-break
  merge algorithm, special/added-token handling under
  `add_special_tokens=false`, and a worked example deriving
  `prompt_token_ids = [6403, 1980, 253, 655]` from the literal prompt
  string. §3.1.2 pins the reference library as a normative fallback
  (`tokenizers` crate v0.23.1) for any edge case the algorithm text does
  not resolve, per this spec's existing pattern of citing external
  standards (`sha256`, §2.1). No test-vector value in §13 changed; this
  entry only makes an already-correct, already-pinned token-id list
  reproducible from spec text alone. Verified by re-fetching the exact
  `tokenizer.json` (hash-checked against §2.1/§3.1.1) and confirming the
  Python `tokenizers` binding reproduces the pinned ids.

---

## Appendix A — source citations (informative; not required to implement this spec)

Every normative choice above is taken from this repo's `src/` at the
commit checked out on branch `cm/e15i-spec-v0.2-doc` (based on
`origin/cm/e15h-ref-fixes`, commit `98f541f`). Reference implementation
state: post-E15h refactor (`docs/E15h_REFACTOR_v0.2_RESULT.md`), i.e. raw-
byte digest hashing, table-digest binding, and theta-general `ln_pinned`
all present. Citations below cover only what changed or is new versus
v0.1's Appendix A; unlisted sections (§1, §2.1–2.3/2.5, §3, §4, §5, §6.1–
6.4, §8, §9.2–9.4, §10, §11.2) are unchanged from v0.1 and cite the same
`file:line`s v0.1's own Appendix A already gives.

- §2.4 (removed restriction): v0.1's `rope_theta==100000.0` assert is gone
  from `src/main.rs`; `rope_theta` is read at `src/main.rs:331` and passed
  directly to `math::ln_pinned` at `src/main.rs:345`, with no equality
  assertion in between.
- §6.5 `ln_pinned`: `src/math.rs:272-303` (`ln_pinned`), coefficient
  consts `src/math.rs:240-254` (`LOG_SQRTHF`, `LOG_Q1`, `LOG_Q2`,
  `LOG_P[0..9]`), unit test `src/math.rs:404-428`
  (`ln_matches_std_within_tolerance`, the tested-`x` set cited in §6.5).
- §6.5.1 `frexp_exact`: `src/math.rs:256-267`.
- §6.6 table digest (extended): `src/math.rs:337-367` (`table_digest`,
  the three new `h.update(...)` lines for `LOG_SQRTHF`/`LOG_Q1`/`LOG_Q2`/
  `LOG_P` are `src/math.rs:360-365`).
- §7.1 `inv_freq` construction (generalized): `src/main.rs:334-354`
  (comment block explaining the E15d(c) generalization, then `let
  ln_theta = math::ln_pinned(rope_theta as f32);` at `src/main.rs:345`,
  the `inv_freq` loop at `:346-354`).
- §7.2 `inv_freq_table_digest` (now bound into witness, still same
  construction): `src/main.rs:358-365` (digest computation, unchanged
  from v0.1's own Appendix A citation), `src/main.rs:516`
  (`witness.update(inv_freq_table_digest)`, new call site).
- §9.1 QKV bias (new, informative for SmolLM2-135M which has none):
  `src/main.rs:90-97` (`add_bias_opt`), call sites `src/main.rs:155,157,159`.
  `LayerWeights.{q,k,v}_bias: Option<Vec<f32>>` fields `src/main.rs:35-37`;
  loader `src/main.rs:376-380` (`load_bias_opt`), populated
  `src/main.rs:407-409`.
- §11.1 untied LM head (new, informative for SmolLM2-135M which is tied):
  `Model.lm_head: Option<Vec<f32>>` field `src/main.rs:56`; load-time
  branch on `tie_word_embeddings` `src/main.rs:415-423`; consumption at
  forward time `src/main.rs:219-220`.
- §12.1 raw-byte witness header: `sha256_file` now returns `[u8; 32]`,
  `src/main.rs:245-250` (doc comment explicitly citing "CIS-2 v0.2 §12.1"
  at `:241-244`); witness seeding order `src/main.rs:555-561`
  (three artifact hashes first — weights, tokenizer, config — then
  `table_digest`, then `inv_freq_table_digest`, then prompt tokens); display-only hex helper `src/main.rs:252-261`
  (local `mod hex`).
- §13.1 test vector values: `docs/E15h_REFACTOR_v0.2_RESULT.md` (full
  run transcript, `runs_identical = true`, this branch's commit
  `f227b43`+`36b5a0f`).
- §13.4 compiler-invariance matrix: `.github/workflows/e15d-compiler-invariance.yml`
  (`TARGET_DIGEST` updated to `a0c563ef...` on `cm/e15i-spec-v0.2-doc`,
  superseding the v0.1-targeted value recorded in
  `docs/E15d_a_COMPILER_INVARIANCE.md`); results in
  `docs/E15d_v0.2_DIGESTS.md` (this branch).
- Everything else (§1 FTZ/DAZ, §2.1/2.2/2.5 artifact+config+tensors, §3
  tokenizer/prompt/decode, §4 bf16 widening, §5 reductions, §6.1–6.4
  rsqrt/exp/sin/cos, §8 RMSNorm, §9.2–9.4 attention score/softmax/V-mix,
  §10 MLP, §11.2 argmax): unchanged `file:line`s from v0.1's own Appendix
  A, reproduced there in full and not re-cited here to avoid drift between
  two documents describing the same unchanged lines.

## Appendix B — where this spec found the reference itself inconsistent or unpinned

(Every item cross-referenced to its §14 discussion above; v0.1's four
items are carried forward with their resolution status noted; no new
items were found during the v0.2 refactor beyond what v0.1 already
flagged.)

1. **RoPE `inv_freq` is theta-specific by construction: CLOSED in v0.2.**
   v0.1 flagged that `LN_THETA` was a bare literal despite surrounding code
   describing the implementation as "architecture-general... driven
   entirely from `config.json`". v0.2's `ln_pinned(rope_theta)` closes
   this specific inconsistency — the RoPE leg is now actually
   config-driven, matching the surrounding claim. Residual caveat: "closed"
   here means "no longer hardcoded to one value," not "proven correct for
   all values" — see §14.1's narrower, honest restatement. §14.1.
2. **Table digests not folded into `CIS2_REF`: CLOSED in v0.2.** §12.1
   items 1-2 now bind both digests. Residual caveat noted in §14.3: a
   `CIS2_REF` mismatch alone still does not localize *which* input
   diverged. §14.3.
3. **Digest byte encoding (hex-ASCII vs. raw bytes): CLOSED in v0.2.**
   `sha256_file` now returns `[u8; 32]`; there is no longer a hex `String`
   for the witness-chain call site to consume, so this can no longer
   silently regress to the v0.1 behavior without changing the function's
   own return type (a much harder mistake to make silently than v0.1's
   "call site happened to pick `.as_bytes()` on a hex `String`"). §14.2.
4. **`rsqrt`/`sqrt`/`/` remain the only operations in this whole spec that
   are unconditionally, provably cross-ISA-identical by the IEEE-754
   standard itself** — unchanged by v0.2; `exp`, `sin`, `cos`, and now
   `ln` are all pinned "by fiat" and have no such guarantee outside this
   document's specific coefficients. Carried forward verbatim as a
   standing caution, now covering one more transcendental (`ln`) than
   v0.1's version of this item.