Download Bitstate/BitState_PoC_experiment_matrix_EN_v0.5.md from mktnhr/BitState: direct link, hf CLI and curl.
- Browser
- Download file 7.92 kB
-
https://huggingface.co/datasets/mktnhr/BitState/resolve/main/Bitstate/BitState_PoC_experiment_matrix_EN_v0.5.md
- Command line
-
hf download hf://datasets/mktnhr/BitState/Bitstate/BitState_PoC_experiment_matrix_EN_v0.5.md
-
curl -L -o BitState_PoC_experiment_matrix_EN_v0.5.md https://huggingface.co/datasets/mktnhr/BitState/resolve/main/Bitstate/BitState_PoC_experiment_matrix_EN_v0.5.md
BitState / HSDR PoC Experiment Matrix — v0.5
Purpose: make the experiment falsifiable, separate state-count correctness from numerical representation error, and test the new dependency-breaking pure-LNS path against the dyadic reference path.
A. Correctness layers
| ID | Test | Input | Reference | Candidate output | Required result |
|---|---|---|---|---|---|
| C0 | LNS8 decode | all codes 0..127, both signs | FP64 formula | decoded value | exact within FP rounding |
| C1 | phase/band decomposition | all non-zero codes | direct formula | phase=k&7, band=k>>3 |
exact |
| C2 | direct 8-phase accumulation | K=128 vectors | direct LNS8->FP64 sum | A[L3] += ±(1<<E4) |
exact within FP rounding |
| C2b | ternary signed population | K=128 vectors | direct state tally | POPCOUNT histogram | bit-exact state counts |
| C2c | direct-vs-histogram phase state | same vectors | direct A[0..7] |
histogram sum_o H[p][o]<<o |
bit-exact A[0..7] |
| C3 | dyadic reconstruction | signed histogram | exact LNS8->FP64 sum | shift/add reference | equivalent within FP rounding |
| C4 | population folding | n=1..128 identical states |
FP64 n*x |
k + 8*log2(n) |
exact in real math; quantify LUT rounding |
| C5 | fractional LNS same-sign add | exhaustive/sampled state pairs | FP64 add then log | kappa+ path |
quantify internal-code error |
| C6 | fractional LNS subtract | opposite signs incl. equality | FP64 subtraction | kappa- + zero handling |
exact zero for equal magnitude; quantify others |
| C7 | balanced pure-LNS tree | random/adversarial K=128 | direct FP64 ternary dot | tree result | error vs internal fractional precision |
| C8 | shared scale in log domain | random positive scales | direct d*sum |
log-offset scale | quantify scale-offset error |
| C9 | Q9.6 boundary | relevant output range | FP64 / wide fixed | Q9.6 | quantify rounding/saturation; not assumed lossless |
B. State-distribution sweep
| Distribution | Why |
|---|---|
| one repeated state | best case for population folding |
| 8 phases, one band | isolates phase reduction |
| one phase, 16 bands | tests intra-phase balanced LNS reduction |
| octave/band sweep | tests exact +8-code relative positioning |
| uniform random codes | high-cardinality stress case |
| Gaussian-like encoded values | generic realistic distribution |
| captured post-Hadamard Bonsai 2 activations | primary real workload |
For each 64/128-element tile record unique-state count U, non-zero signed bucket count B, and active phase count P.
C. Weight-distribution sweep
| Pattern | Purpose |
|---|---|
| all +1 | sign-free reference |
| alternating +/- | exact cancellation stress |
| {-1,0,+1} uniform | generic ternary |
| measured Bonsai 2 trit distribution | real workload |
| high zero fraction | tests skip / nonzero mask benefit |
D. Reuse / amortization sweep
Build activation state representation once and reuse it for N output rows.
N = 1, 8, 32, 128, 512, 2048
Report separately:
T_encode = activation LNS8 encoding
T_stateset = reusable state-set construction
T_intersect = one row's weight-mask intersection + POPCOUNT
T_reduce_dyad = dyadic reference reduction
T_reduce_lns = pure fractional-LNS reduction
T_scale = scale application / log-offset handling
T_total_ref(N) = T_encode + T_stateset + N*(T_intersect + T_reduce_dyad + T_scale)
T_total_lns(N) = T_encode + T_stateset + N*(T_intersect + T_reduce_lns + T_scale)
E. Kernel variants
| ID | Variant | Purpose |
|---|---|---|
| B0 | current fork ternary dot | baseline |
| B1 | scalar direct decode | simple reference |
| D0 | scalar direct 8-phase accumulator | correctness baseline for A[L3] += ±(1<<E4) |
| D1 | Tile64 direct phase-mask routing | primary ordinary-CPU K→8 reduction candidate |
| D2 | Tile32 word-width equivalent | CPU/GPU width-invariance correctness check |
| P0 | scalar signed histogram | validates state-count math |
| P1 | full-state masks rebuilt per row | intentionally unamortized comparison |
| P2 | reusable sparse state masks | primary dependency-breaking hypothesis |
| P3 | phase-local signed histogram | compares explicit population path with direct A[8] |
| P4 | AVX2/SWAR state construction + POPCNT | optimized CPU state front-end |
| R0 | dyadic shift/add materializer | reference post-POPCOUNT path |
| L0 | scalar fractional-LNS add/sub | correctness reference |
| L1 | balanced sparse-bucket pure-LNS tree | primary pure-LNS CPU hypothesis |
| L2 | 8-phase normalized 120..127 anchor path |
tests relative-state normalization |
| P5 | PTQ1_0 integrated decode | dense-packing follow-up |
| G0 | CUDA ballot state-per-lane | GPU front-end candidate |
| G1 | CUDA match-any grouping + balanced state reduction | GPU candidate |
F. K sweep
K = 32, 64, 128, 256, 4096, 5120, 8192
K=128 is especially important because it aligns with Bonsai 2 scale groups.
G. Fractional-LNS precision sweep
Test internal fractional code bits independently of storage LNS8:
F = 4, 6, 8, 10, 12, 14
For each F, generate count_log[n], kappa_plus[d], and kappa_minus[d] from a high-precision reference. Measure pairwise error, full-tree error, and LUT footprint.
H. Reduction-order / dependency sweep
Compare:
serial left fold
balanced tree
phase-local balanced tree -> 8-phase 8->4->2->1 tree
sparse global balanced tree
Report both operation count and dependent critical-path stages. This is a first-class metric, not a secondary implementation detail.
I. CPU metrics
- ns / 128-weight group
- cycles / output row
- cycles / weight
- instructions / weight
- uops / IPC
- product-state ADD cost
- phase-mask / selector build cost
- direct K→8 weighted reduction cost
- state-set build cost for histogram variants
- unique states / non-zero signed buckets
- POPCNT count and throughput
- fractional-LNS LUT loads
- dependent LNS-add/sub stages
- L1/L2 misses
- actual memory bandwidth
- crossover reuse count vs baseline
J. End-to-end metrics
- TG128
- PP512 as secondary context
- model load / memory footprint unchanged unless explicitly testing metadata
- quality/perplexity or task check vs existing fork
- LNS8 saturation / underflow rate
- pure-LNS vs dyadic end-to-end delta
K. Reporting rule
Always report at least these components separately:
1. activation / product-state encoding
2. phase-mask / selector construction
3. direct K→8 weighted reduction
4. state-set construction + POPCOUNT (histogram variants)
5. eight-phase dyadic finalization
6. pure-LNS reduction cost
7. dependent critical-path depth
8. end-to-end integrated result
This prevents a fast microkernel from hiding conversion costs and prevents a slow first implementation from hiding the benefit of reusable state sets or a shallower reduction dependency graph.
L. Reference artifact for direct 8-phase correctness
Use LNS8_base74_8step_zone8_popcount_demo_JA_v0.8_bitslice128_validation.xlsx as the visual reference for the direct path:
Inputs_128-> two Tile64 blocks;S1|E4|L3decomposition;- phase masks as intermediate routing selectors;
±(1<<E4)routed into eight integer accumulators;- equality against direct decoded sum.
This workbook proves correctness of the reduction identity, not performance.
M. Stop / continue decision
Continue optimization if at least one realistic region shows either:
- lower per-output-row cost after amortization;
- materially lower dependent reduction depth with competitive total work;
- lower memory traffic with competitive latency;
- pure-LNS finalization beats or simplifies the dyadic materializer without unacceptable quality loss.
Stop or redesign if real post-Hadamard state cardinality, mask/POPCOUNT cost, or fractional-LNS LUT/reduction cost leaves no crossover against the existing ternary kernel.