OMEGA: INTEGRATED VALUE + ORDERED LETTER-NUMBER-DIRECTION RECORD
Prepared for Matthew Alan Newman (@NVE024)
Integration date: 2 November 2026, America/New_York

RESULT
The actual Paper IX value-plus-indicator codec now supports ordered direction
symbols and their corresponding three-letter groups. Encoding and decoding
work on the full signed 120-coordinate integer model. The existing exact core
is retained, and conversions preserve its output and packed witness.

This implemented witness uses 360 bits (45 packed bytes). Its directional
representation uses 140 symbols, or 140 three-letter groups (420 letters).
The separate 352-bit existence bound is unchanged. The included 137-symbol
format converts an already supplied 352-bit integer; it does not compute a
352-bit OMEGA fiber index.

ALPHABET
Digit / direction / ordered letters / ordered numbers:
0 / Up    / YHV / 10,5,6
1 / Down  / YVH / 10,6,5
2 / East  / HYV / 5,10,6
3 / West  / HVY / 5,6,10
4 / South / VYH / 6,10,5
5 / North / VHY / 6,5,10

The letter/direction correspondence follows the specified Sefer Yetzirah 1:13
text on Sefaria; other recensions differ. The digit assignment is a modern
encoding choice. These labels express an ordered recovery code and do not
assign the 600-cell's 120 vertices to six spatial directions.
Every group has gematria 21. Every full record totals 2940. The sum cannot
identify the record; the ordered groups do.

EXACT CONSTRUCTION
M=13I+A on the pinned 120-vertex 600-cell graph.
Q=339949771344778; D=25000000000000000.
For integer input d, output y=floor(QMd/D) componentwise.
For coordinate i, r_i=d_i mod 8 in {0,...,7}.
Pack R=sum_i r_i*8^(119-i), so 0<=R<2^360.
Write R in exactly 140 base-six positions, most significant first, keeping
leading zeros as Up. Replace digits by the listed directions or letter groups.
Decode the symbols to R, restore its 120 base-eight residues, and call the
existing exact inverse-interval and finite-search decoder.
The parser rejects 140-symbol strings whose integer exceeds the 360-bit range.

WHY THE COMBINED RECORD IS UNIQUE
Suppose two original inputs give the same output and the same ordered code.
Reversing the base conversion gives equal residues, hence d-e=8k for an integer
vector k. Equal outputs imply |M(d-e)|<=73 in every coordinate because
73Q<D<74Q. Therefore |Mk|<=9 coordinatewise.
The exact matrix certificate establishes M-9I positive definite. If k were
nonzero, k^T M k>9 sum(k_i^2). But |Mk|<=9 gives
k^T M k<=9 sum|k_i|<=9 sum(k_i^2), a contradiction. Thus d=e.
This proves injectivity for every input in the declared integer domain.
Finite example tests support the implementation; they are not the basis of
the universal theorem. This integration is not an end-to-end Lean proof.

ACTUAL SAME-OUTPUT EXAMPLE
Use inputs whose only potentially nonzero entries are the final two:
d=(0,...,0,1,0) and e=(0,...,0,1,5).
Both reduced outputs are the all-zero 120-coordinate vector.
Their packed witness integers are 8 and 13.
The direction records have 138 leading Up symbols and then respectively:
  Down,East  -> YVH,HYV
  East,Down  -> HYV,YVH
The numerical letter totals and spatial endpoints match. The order differs,
and decoding recovers each original exactly.
Also all 120 unit inputs e_i share output zero and receive distinct records.

VERIFICATION IN THIS INTEGRATION
- 46,656 six-symbol records exhaustively checked against positional arithmetic.
- 153 full 120-coordinate input recoveries, including negative and 100-digit values.
- 120 same-output unit inputs separated and recovered.
- 302 JSON record round trips across both directional and letter forms.
- 48 generic integer boundary checks at 352 and 360 bits.
- 41 invalid-input cases rejected; 6 malformed/duplicate/non-finite JSON cases rejected.
- 8 public command-line operations checked.
- All 120 positive principal determinants of M-9I rechecked with exact arithmetic.
- Normal and optimized Python runs produced byte-identical result and example files.

The decoder has a complete finite search and an explicit optional budget.
A budget failure produces an error, never a guessed original. Worst-case
polynomial runtime or a speed advantage is not established. Textual direction
or letter forms are larger than the 45-byte packed witness. The output and
metadata are additional to that witness. This representation does not provide
authentication by itself.

FILES AND REPRODUCTION
Updated package: OMEGA_Value_Indicator_Codec_v1.zip
Stable reference:
https://chatgpt.com/library?file_id=libfile_7a6a0f122a18819193944942cf7d7f50&account_id=personal

Inside the package:
  omega_directional.py: integrated encoder/decoder and format conversion.
  omega_indicator.py: unchanged core encoder and exact decoder.
  DIRECTIONAL_INTEGRATION_PROOF.md: complete definitions and proof.
  alphabet.json: pinned table, edition, and source URLs.
  verify_directional.py: reproducible integration checks.
  directional_verification.json: executed results.
  directional_examples.json: actual same-output records and original inputs.
  execution_comparison_directional.json: normal/optimized agreement.
  integration_provenance.json and SHA256SUMS.txt: provenance and hashes.
  TRANSFER_PROMPT.txt: compact handoff to the Paper IX thread.

Python 3.10 or later, standard library only. From the extracted package:
  python3 omega_directional.py demo
  python3 omega_directional.py encode input.json letters.json --form letters
  python3 omega_directional.py decode letters.json recovered.json --max-nodes 1000000
  python3 omega_directional.py convert letters.json legacy.json --form core
  python3 verify_directional.py --output-dir checks/normal
  python3 -O verify_directional.py --output-dir checks/optimized

input.json contains exactly 120 integers. The API also offers max_nodes=None
for unlimited complete finite search.

SOURCES
Historical table:
https://www.sefaria.org/Sefer_Yetzirah.1?lang2=en&with=Translations
Letter values:
https://www.chabad.org/kabbalah/article_cdo/aid/1381789/jewish/The-Alphabet-Letters-of-the-Torah.htm
The conversion to a positional digital code is the implementation described
here, not a claim about an ancient computer or cipher.

EXACT SOURCE AND RESULT HASHES
baseline/verify_structure.py: 57100e240ba7d1a8c10c133e51937461cf6b9b0cb1ef1602671095bd4375917b
omega_directional.py: 3ffaee2b334b79eeea1ec72530bfebf9cb891d9003dd9a452acc062926090df7
omega_indicator.py: fba18e7dc2a652187e4b89963f4904093e789e644c3e0e88a69671008784698a
verify_directional.py: 2b3943d9498234885b591d0c0ffe04586abeb6ea8c86148debff56488bb6a013
directional_verification.json: f94050c5cf86b040c7ac899f9dfabfb576dd33878818a0476ba3fdab48a00272
