# Authoritative Reference Implementation and Test Report

**Implementation:** `omega_alpha_reference.py`  
**Version:** 1.0.0  
**Runtime:** Python 3.10+  
**Dependencies:** Python standard library only  
**Test status:** **PASS**

## 1. Scope

The implementation covers the finite, exactly testable parts of the Omega-Alpha synthesis:

- high-precision verification of \(\phi\), \(\pi\), \(\lambda_\Omega\), and \(\kappa\);
- fixed rational protocol constants \(S,Q,N\);
- the exact Euclidean boundary-witness contraction and reconstruction;
- the full \(N\)-step witness identity;
- reversible 15-bit byte folding;
- byte and 16-bit monotone codebooks;
- corrected Newman-Ramanujan ellipse-coordinate values;
- negative tests for malformed witnesses and non-codeword inputs.

The implementation does not treat `Decimal` arithmetic as symbolic exact arithmetic. Exactness begins after the integer protocol constants are fixed.

## 2. Verified constants

The reference evaluation uses Decimal arithmetic, \(\sqrt{5}\), and Machin's formula

\[
\pi=16\arctan(1/5)-4\arctan(1/239).
\]

The following values were reproduced:

| Quantity | Verified value |
|---|---:|
| \(\phi\) | `1.61803398874989484820458683436563811772030917980576` |
| \(\pi\) | `3.14159265358979323846264338327950288419716939937511` |
| \(\lambda_\Omega\) | `0.33994977134477892957670280932127919355100990501426` |
| \(\kappa=-\log\lambda_\Omega\) | `1.07895740362416456641369720327285296513863541099576` |
| \(\lambda_\Omega^{23}\) | `1.66931896786205854202278982544429603856787514680458E-11` |
| \(S\) | `1000000000000000` |
| \(Q\) | `339949771344778` |
| \(N\) | `23` |

The scaled floor \(Q=\lfloor S\lambda_\Omega\rfloor\) was independently re-evaluated at 70 and 90 decimal digits; both evaluations returned the protocol integer `339949771344778`.

## 3. Exact boundary-witness kernel

For each integer state \(d_k\), the implementation computes

\[
d_{k+1}=\left\lfloor\frac{Qd_k}{S}\right\rfloor,
\qquad
\rho_k=Qd_k-Sd_{k+1}.
\]

Reverse reconstruction validates

\[
d_k=\frac{Sd_{k+1}+\rho_k}{Q}
\]

by checking:

1. integer types with `bool` rejected;
2. \(0\le\rho_k<S\);
3. exact divisibility by \(Q\);
4. complete forward replay of the reconstructed value;
5. equality of the full witness identity.

### Exhaustive 15-bit result

Every value in

\[
\{0,1,\ldots,32767\}
\]

was tested.

| Test | Result |
|---|---:|
| Values tested | `32768` |
| Exact reverse round trips | `32768 / 32768` |
| Full witness identities | `32768 / 32768` |
| Terminal state after 23 steps | zero for all values |
| Maximum steps actually needed to reach zero | `10` |

This confirms that 23 is a fixed padded protocol horizon rather than the minimal extinction depth of the 15-bit domain.

## 4. Reversible 15-bit byte folding

The rule `fold15_be_lsbpad_v1` was tested on:

- the empty byte string;
- single zero and all-one bytes;
- `JPRV-LEGEND`;
- `bytes(range(256))`;
- a deterministic 1025-byte pattern.

All vectors round-tripped exactly. Strict validation rejects inconsistent lengths and nonzero padding bits.

## 5. Byte codebook

The codebook is

\[
T(b)=F^{23}((b+2)S),\qquad b\in\{0,\ldots,255\}.
\]

### Exhaustive results

| Property | Result |
|---|---:|
| Entries | `256` |
| \(T(0)\) | `33386` |
| \(T(65)\) | `1118443` |
| \(T(255)\) | `4290149` |
| Minimum adjacent difference | `16692` |
| Maximum adjacent difference | `16694` |
| Residual range in \(T(b)=16693(b+2)+\varepsilon_b\) | `0..48` |
| Direct nearest-integer decoder | exact for all 256 entries |
| Compact-JSON array SHA-256 | `0fc8922c2d84cfd965c9fe310070e00ffd86ed76117584a9ff2faa85136a0c47` |

The digest agrees with the sealed byte table supplied in the conversation.

## 6. Full 16-bit codebook

The same map was exhaustively evaluated for

\[
b\in\{0,\ldots,65535\}.
\]

| Property | Result |
|---|---:|
| Entries | `65536` |
| First tick | `33386` |
| Second tick | `50079` |
| Final tick | `1094021571` |
| Minimum adjacent difference | `16692` |
| Maximum adjacent difference | `16694` |
| Strictly increasing | yes |
| Iterative decoder plus exact replay | exact for all 65536 entries |
| Expanded normalized error interval | `[-0.000095642173670, -0.000021959084760]` |
| UInt64 big-endian map SHA-256 | `c0d90669759bfe4c2efc7692ba74496249f9ff1f63748166afb19232724f8ff8` |

The direct byte-domain formula using \(C=16693\) is not used for the full 16-bit domain because its residual exceeds \(C/2\) at larger seeds. The accepted 16-bit decoder performs repeated approximate expansion, rounds, and then requires exact forward replay.

## 7. Corrected ellipse-coordinate table

The reference table follows the revised finite policy:

1. evaluate Ramanujan's multiplier at high precision;
2. truncate the multiplier to 15 decimal places;
3. compute the coordinate using the declared literal
   \(\lambda_{15}=0.339949771344778\);
4. truncate the coordinate to 15 decimal places.

| Aspect ratio | Multiplier \(w\) | Coordinate \(v\) |
|---:|---:|---:|
| 1 | 1.000000000000000 | 1.000000000000000 |
| \(\phi\) | 1.013981238987019 | 1.041127366939274 |
| 2 | 1.027976282991305 | 1.082295342869730 |
| 3 | 1.063544374901302 | 1.186922834658579 |
| 4 | 1.092238310579021 | 1.271329232592636 |
| 5 | 1.114616532029377 | 1.337157255838047 |
| 6 | 1.132275132275132 | 1.389101989249400 |
| 7 | 1.146475593679134 | 1.430874223270407 |
| 8 | 1.158109192642229 | 1.465095746400353 |
| 9 | 1.167799597839498 | 1.493601149298362 |
| 10 | 1.175989279709379 | 1.517692007890454 |

The inconsistent alternate value `1.027976685646542` found in an earlier ellipse table is rejected.

## 8. Negative tests

The test suite confirms rejection of:

- `bool` where an integer is required;
- inconsistent fold padding;
- an altered remainder ledger;
- a non-codeword passed to the byte decoder.

All negative tests passed.

## 9. Original strict JPRV implementation

The uploaded duplicate scripts

- `jprv_legend_v024_strict_compact 2(1).py`
- `jprv_legend_v024_strict_compact 3(1).py`

have identical SHA-256 hash

`f1adc3a937b800936ce2fd088c107fdf71d1bfff69e839456d6ca17e01695ab0`.

Executing the source script produced:

```text
JPRV V0.2.4 strict reference self-test: PASS
```

The master implementation does not replace the full capsule/root/model schema in that script. It provides a smaller theorem-oriented kernel and test suite suitable for the preprint.

## 10. Reproduction commands

```bash
python omega_alpha_reference.py --pretty
python omega_alpha_reference.py --pretty --report reference_test_report.json
```

A successful run ends with

```json
"overall": "PASS"
```

## 11. Interpretation of the test result

The tests establish:

- exact recovery of represented finite integers;
- exact reversibility of the declared 15-bit folding rule;
- the stated finite-domain codebook properties;
- reproducibility of the corrected ellipse table;
- consistency of the fixed protocol constants.

They do not establish:

- exact recovery of information lost before quantization;
- universal physical correctness;
- data compression;
- cryptographic authentication or secrecy;
- superiority over existing geometric, collision-detection, or distributed-systems methods.