Datasets:

aefinityAIINC
/

cis2-conformance

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:lines 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:

If x is NaN, return NaN.
If x > 88.0, return +Infinity.
If x < -88.0, return 0.0.

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

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].)
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:

If x is NaN or x < 0.0, return NaN.
If x == 0.0, return -Infinity.
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).

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

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:

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.
tokenizer_sha256 — same raw-32-byte encoding, tokenizer.json's digest.
config_sha256 — same raw-32-byte encoding, config.json's digest.
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.
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).
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.
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/):

It reproduces every value in §13.1 bit-for-bit, on x86-64.
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).
Its release binary contains zero FMA instructions on the decode path (§1.4, disassembly-verified).
Its self-test (§1.3's adversarial denormal check) passes.
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:lines 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:lines 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.)

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.
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.
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.
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.

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

0. Scope and non-goals (normative)

1. Floating-point environment (normative)

2. Model artifact (normative)

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

4. bf16 → fp32 widening (normative)

5. Numeric reduction primitives (normative)

6. Transcendental functions (normative)

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

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

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

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)

6.4 SiLU

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

6.5.1 frexp_exact(x) — exact mantissa/exponent split

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

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

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

8. RMSNorm (normative)

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

10. MLP / SwiGLU (normative)

11. LM head and argmax (normative)

12. Digest / receipt format (normative)

13. Test vectors (normative)

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

15. Conformance (normative)

16. Version history

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

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

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

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