# OMEGA as a reference language

OMEGA can be read as a formal language of referenced states, transformations, discrepancies, and recovery. A record names the shared reference and arithmetic, states what was retained, and supplies a rule for recovering its defined content. This page makes those meanings explicit and introduces a small executable record grammar.

This is a proposed formalization developed on 24 October 2026 from the proved operators. The new `OMEGA-LANGUAGE 0.1` prototype is separate from existing SRSD specifications, OMEGA_READOUT versions, TGA identifiers, and the October thesis's earlier serialization grammars.

[Decipher a record in the browser](/tools/omega-language/) · [Read the compatibility proof](/geometry/unification) · [Read the broader recovery proofs](/geometry/reference-recovery)

## Vocabulary and meanings

| Symbol or object | Meaning |
|---|---|
| \(K\) | The shared labeled OMEGA template |
| \(p\in K\) | A corresponding labeled reference point |
| \(a\), \(K_a\) | A nonnegative scale and the placement \(p\mapsto ap\) |
| \(\lambda\) | The selected ideal factor \(\varphi/(\varphi+\pi)\) |
| \(q=Q/S\) | The exact rational implementation factor |
| \(T(d)\) | The integer next-state \(\lfloor qd\rfloor\) |
| \(\rho\) | The Euclidean remainder \(Qd-ST(d)\) |
| \(w\) | A predecessor's rank within the output's floor fiber |
| An ordered ledger | Side information that distinguishes the predecessors of successive outputs |
| A content codec | An explicit convention interpreting a recovered integer as a scale, bytes, or text |

The grammar is typed. A template point, real scale, integer state, rank, and remainder have different roles. A real-to-integer conversion must be declared; its discarded information is not automatically present in a later integer ledger.

## Reading a mathematical sentence

Write

\[
d\xrightarrow{q,\rho}d'.
\]

Read it as: under the declared rational contraction, integer scale \(d\) produces integer scale \(d'\), while retaining remainder \(\rho\).

The sentence is arithmetically valid exactly when

\[
d,d'\in\mathbb N_0,\quad Qd=Sd'+\rho,\quad0\le\rho<S.
\]

Its corresponding geometric statement is

\[
q(dp)=d'p+(\rho/S)p\qquad(p\in K).
\]

Every corresponding point has the same scale correction. Its decoder is \(d=(Sd'+\rho)/Q\), with bounds and divisibility checked. For the actual ideal factor, the correction is \(\rho/S+(\lambda-q)d\). The names \(q\) and \(\lambda\) are never interchangeable.

Mathematical assertions have interpretations fixed by these definitions. A byte or text message uses an additional stated codec. Recovering a name preserves that name and its declared interpretation; the shape does not independently supply an unspecified external referent.

## The shared context

The prototype binds these fields:

- `TEMPLATE OMEGA-CANONICAL-DOWN/1`: the unit-circle reference with downward canonical one-arcsecond opening, the six named baseline marks, the declared extensions, origin at the circle center, and fixed axes.
- `UNITS calibrated-scale`: dimensionless multiples of the common unit reference radius. A physical unit conversion or external pose must be separately supplied when needed.
- `Q 339949771344778` and `S 1000000000000000`: the canonical rational floor map.
- `CODEC scale`, `CODEC bytes-sentinel`, or `CODEC utf8-sentinel`: the interpretation of the recovered initial integer.
- `STEPS`, `TERMINAL`, and `RANKS`: the framing, terminal state, and ordered predecessor witnesses.

The template's geometry is defined by the existing construction and complete proof. The language identifier is not a new kernel-coordinate evaluator or a replacement for `OMEGA_KERNEL_NODES/1.0`.

## A concrete record grammar

The canonical representation is ten ASCII lines in the following order. Decimal integers have no sign or leading zeros, except the integer zero itself. The serializer emits LF line endings and one final newline; the parser also accepts CRLF line endings and permits the final newline to be omitted.

```text
record   = magic NL template NL units NL q NL s NL codec NL
           steps NL terminal NL ranks NL "END" [NL] ;
magic    = "OMEGA-LANGUAGE 0.1" ;
template = "TEMPLATE OMEGA-CANONICAL-DOWN/1" ;
units    = "UNITS calibrated-scale" ;
q        = "Q 339949771344778" ;
s        = "S 1000000000000000" ;
codec    = "CODEC " ("scale" | "bytes-sentinel" | "utf8-sentinel") ;
steps    = "STEPS " uint ;
terminal = "TERMINAL " uint ;
ranks    = "RANKS" { " " rank } ;
rank     = "0" | "1" | "2" ;
uint     = "0" | nonzero {digit} ;
nonzero  = "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
digit    = "0" | nonzero ;
```

Here `NL` denotes a permitted line ending; braces mean repetition and brackets mean optional syntax. Exactly one space separates fields and rank symbols. There are no unknown, duplicate, or reordered fields. The rank count must equal `STEPS`.

Syntax alone is not enough. For output \(y\), let

\[
b(y)=\left\lceil\frac{Sy}{Q}\right\rceil.
\]

At each reverse step require

\[
0\le w<b(y+1)-b(y),\qquad d=b(y)+w.
\]

The resulting initial integer must also satisfy its declared content codec. These tests distinguish a parseable string from a valid record.

The mathematical grammar permits finite records of any finite size. The provided browser implementation accepts a bounded working subset: at most 256 transitions, 512 decimal digits per integer, and 128 payload bytes. Its parser also has a 20000-character record limit. These are explicit computation limits, not limitations of the all-finite-history proof.

## Deciphering scale 26

```text
OMEGA-LANGUAGE 0.1
TEMPLATE OMEGA-CANONICAL-DOWN/1
UNITS calibrated-scale
Q 339949771344778
S 1000000000000000
CODEC scale
STEPS 3
TERMINAL 0
RANKS 2 2 2
END
```

The reverse rule gives

\[
0\mapsto b(0)+2=2\mapsto b(2)+2=8\mapsto b(8)+2=26.
\]

In forward order, its content is

\[
26\xrightarrow{w=2}8\xrightarrow{w=2}2\xrightarrow{w=2}0.
\]

This identifies the initial scale, the intermediate states, and every corresponding reference \(K_{d_k}\). An independent normalized point \(u\) would need its own retained measurement or coordinate record.

## Deciphering text A

For a byte message \(m\), the sentinel code is

\[
N(m)=256^{|m|}+\operatorname{value}_{256}(m).
\]

The shortest unsigned big-endian representation of a valid code begins with byte `01`. Remove that byte to recover the message, including its length and any leading zero bytes.

Under UTF-8, `A` has byte `41` in hexadecimal. Prepending the marker gives `01 41`, the integer 321. Its record is

```text
OMEGA-LANGUAGE 0.1
TEMPLATE OMEGA-CANONICAL-DOWN/1
UNITS calibrated-scale
Q 339949771344778
S 1000000000000000
CODEC utf8-sentinel
STEPS 6
TERMINAL 0
RANKS 0 0 1 0 1 1
END
```

The reconstructed forward history is

\[
321\to109\to37\to12\to4\to1\to0.
\]

Reverse the ranks to recover 321, convert it to bytes `01 41`, remove `01`, and interpret `41` under UTF-8 to recover `A`.

`bytes-sentinel` returns the exact arbitrary byte sequence without assigning text meaning. `utf8-sentinel` additionally requires valid UTF-8. Text input is a sequence of Unicode scalar values: unpaired surrogate inputs are rejected. No normalization is applied, and an initial U+FEFF is retained. The empty byte message has integer code 1; the empty text message uses the same bytes under its declared text codec.

## Recovery is the semantics of the retained record

For a fixed shared context and finite horizon, let \(E\) run the stated transitions and retain terminal and ordered ranks. Let \(D\) apply the reverse rule. Then

\[
D(E(d))=d.
\]

Proof: the exact floor fiber is \(\{b(y),\ldots,b(y+1)-1\}\). Its rank uniquely selects one predecessor. Reverse one step and repeat by backward induction. The framing determines the number of steps. For a message, compose that inverse with the injective sentinel decoder. For text, compose with the declared UTF-8 interpretation on its valid domain.

Consequently, supplied properties and relations can be evaluated after decoding. More generally, a property \(P\) survives an observation \(O\) exactly when it is constant on every observation fiber. An injective representation retains all specified source distinctions. Operation transport \(EfE^{-1}\) preserves the declared operation on the image.

The scope of a record remains explicit. A scale ledger does not supply unrecorded position, rotation, shape changes, or external semantic grounding. Positive-scale planar positions can be recovered through the separate three-anchor contract in the [complete proof](/geometry/unification/OMEGA_Unification_Proofs_Python_Java.md).

## Executable implementation and checks

- [Exact integer language engine](/tools/omega-language/omega-language-core.mjs)
- [Browser decoder](/tools/omega-language/)
- [This language note](/language/OMEGA_Reference_Language_v0_1.md)

The new engine was compared against the unchanged audited Python v2 implementation on all 32768 canonical transitions and eight complete histories. It also round-tripped all 65793 byte messages of lengths zero through two and ten Unicode text examples, and rejected 21 malformed inputs. The browser displayed the scale-26 and text-A decodings and rejected a mismatched step count. These are finite implementation checks with the declared scope.

The engine also checks that changing a valid rank can produce another valid record with a different seed. Arithmetic validity identifies a consistent mathematical record; it does not establish its sender or intended provenance.