# The 399 rational-floor example: definition, proof, and website handoff

Prepared for Matthew Alan Newman. Checked 24 September 2026 (UTC).

## What the live inspection established

The transformation is already public. The live `/dynamics` page states the
constants, the floor formula, the 399 identity, and its inverse. The live
`/reproduce` page links downloadable implementations, and the Paper VIII
reference checker is available as a Python file. The reconstruction tool uses
BigInt. Its explanatory text links to the floor page, but does not display the
complete defining equations beside its default table.

The appropriate correction is to expose the existing mathematics where the
example is encountered, and provide a small executable example. There is no
need to infer a new step function from the observed sequence.

Live URLs retrieved successfully:

- <https://omega-naught.grok.me/>
- <https://omega-naught.grok.me/tools/reconstruct>
- <https://omega-naught.grok.me/start/shape-to-record>
- <https://omega-naught.grok.me/dynamics>
- <https://omega-naught.grok.me/reproduce>
- <https://omega-naught.grok.me/papers/8/omega_reference_checker.py>
- <https://omega-naught.grok.me/LICENSE-CODE>

This inspection used HTTP content retrieval and local code execution. It did
not include a fresh browser interaction session. The website was not edited.

## The exact definition

Fix

\[
Q=339949771344778,\qquad S=10^{15},\qquad q=Q/S.
\]

For a nonnegative integer state \(d\), define

\[
\boxed{F(d)=\left\lfloor\frac{Qd}{S}\right\rfloor},
\qquad
\boxed{\rho(d)=Qd-SF(d)}.
\]

Equivalently, the augmented step is

\[
\boxed{\mathcal E(d)=\operatorname{divmod}(Qd,S)
                  =(F(d),\rho(d)).}
\]

Thus \(0\le\rho(d)<S\), and

\[
Qd=SF(d)+\rho(d),\qquad
qd=F(d)+\frac{\rho(d)}{S}.
\]

The remainder is determined by the input and the map. It is not an additional
adjustment chosen to force a desired next state. Its normalization
\(\rho(d)/S\) is exactly the fractional part discarded by this floor operation.

In Python the complete forward step is:

```python
Q = 339949771344778
S = 10**15

def step(d):
    if type(d) is not int or d < 0:
        raise ValueError("nonnegative integer required")
    return divmod(Q * d, S)  # (next state, remainder)
```

## Why 399 becomes 135

The operation multiplies by
\(q=0.339949771344778\), then takes the floor. It does not divide by three.

\[
Q\cdot399=135639958766566422
          =135\cdot10^{15}+639958766566422.
\]

Therefore

\[
q\cdot399=135.639958766566422,
\qquad F(399)=135,
\qquad\rho(399)=639958766566422.
\]

All displayed decimals in this calculation are exact terminating decimals.
The integer arithmetic in the code does not evaluate these decimal expressions.

| Input \(d\) | Product \(Qd\) | Next state \(F(d)\) | Remainder \(\rho(d)\) |
|---:|---:|---:|---:|
| 399 | 135639958766566422 | 135 | 639958766566422 |
| 135 | 45893219131545030 | 45 | 893219131545030 |
| 45 | 15297739710515010 | 15 | 297739710515010 |
| 15 | 5099246570171670 | 5 | 99246570171670 |
| 5 | 1699748856723890 | 1 | 699748856723890 |
| 1 | 339949771344778 | 0 | 339949771344778 |

This is the six-transition extinction ledger. The terminal state is zero.
The fixed-point step \(0\mapsto0\) exists mathematically but is omitted from
this unpadded ledger.

## Theorem and proof

**Theorem.** For integers \(0<Q<S\), the above definitions give a unique pair
\((F(d),\rho(d))\) for each \(d\in\mathbb Z_{\ge0}\). Every orbit reaches zero
in finitely many steps. A terminal state together with the complete ordered
remainders of a finite trajectory uniquely determines that trajectory.

**Proof.** Apply Euclidean division to the nonnegative integer \(Qd\) with
positive divisor \(S\). It gives unique integers \(d'\ge0\) and
\(0\le r<S\) satisfying \(Qd=Sd'+r\). By the definition of floor,
\(d'=F(d)\) and \(r=\rho(d)\).

For \(d>0\), the inequality \(0<Q<S\) gives
\(0\le F(d)\le Qd/S<d\). Consequently, a positive orbit is a strictly
decreasing sequence of nonnegative integers until it reaches zero. Since
\(F(0)=0\), zero is terminal.

Given a next state \(d'\) and its corresponding remainder \(r\), the previous
state must be

\[
\boxed{d=\frac{Sd'+r}{Q}}.
\]

For a proposed record this expression must be an integer; otherwise the record
is invalid. When it is an integer and \(0\le r<S\), the defining identity
ensures that a forward step returns exactly \((d',r)\). Apply this inverse first
to the last remainder, then successively to each preceding remainder. Every
preceding state is unique. This reconstructs the entire finite trajectory.
\(\square\)

The inverse theorem applies to any finite trajectory prefix when its actual
terminal state is supplied. The accompanying `recover` functions intentionally
implement the narrower unpadded extinction format: terminal zero, with no
zero-to-zero padding transitions.

**Closed reconstruction formula.** For \(n\) transitions and remainders
\((\rho_0,\ldots,\rho_{n-1})\) in forward order,

\[
\boxed{Q^n d_0=S^n d_n+
\sum_{k=0}^{n-1}Q^{n-1-k}S^k\rho_k.}
\]

For \(n=1\) this is the defining identity. If it holds at \(n\), multiply by
\(Q\) and substitute \(Qd_n=Sd_{n+1}+\rho_n\). The resulting expression is the
formula at \(n+1\), proving it by induction. In particular,

\[
d_0=\frac{S^n d_n+
\sum_{k=0}^{n-1}Q^{n-1-k}S^k\rho_k}{Q^n}.
\]

The remainder order matters because different positions carry different powers
of \(Q\) and \(S\). Iterating the one-step inverse avoids forming the large
powers in this closed expression.

**Worked inverse.** The first pair gives

\[
\frac{10^{15}\cdot135+639958766566422}{339949771344778}=399.
\]

Starting at terminal zero and consuming the six remainders in reverse order
gives \(0,1,5,15,45,135,399\).

## Reconstruction and record integrity

The quotient alone does not recover the input: the preimages of 135 are
398, 399, and 400. Their remainders differ, so the quotient-remainder pairs
distinguish them.

Validation requires exact integer types, the correct \(Q,S\), the declared
terminal, remainder bounds, reverse divisibility, and the ledger's ordering
and padding convention. Forward replay checks the recovered values.

These checks do not authenticate the record. Dropping the first remainder
from the 399 ledger produces a valid extinction ledger starting at 135. A
decoder supplied with only that shorter record cannot know that it once
belonged to a longer one. Compare against a trusted record hash, expected
length, expected seed, or other independent provenance when detecting loss or
substitution is required. An attacker-controlled checksum is not such a
trusted reference. The optional expected-seed parameter is a validation aid;
it is not used in the reconstruction formula.

## The geometric scale convention

The walkthrough uses \(a_k=h d_k\) with \(h=1/100\). Thus the geometric scale
sequence is \(3.99,1.35,0.45,0.15,0.05,0.01,0\). In general,

\[
a_{k+1}=h\left\lfloor\frac{q a_k}{h}\right\rfloor,
\qquad q a_k-a_{k+1}=h\frac{\rho_k}{S}.
\]

Changing the external scale \(h>0\) changes the represented lengths, not the
integer step function. It is not needed to explain 399 becoming 135.

The selected geometric readout gives the real parameter
\(\lambda=\varphi/(\varphi+\pi)\). The rational parameter \(q=Q/S\) is distinct.
Agreement of their floors on a stated finite domain is a separate result.
This small package verifies the rational map; it does not prove a new global
equality with the irrational map or rerun the site's enclosure proof.

## Exact implementation requirements

Use Python integers or JavaScript BigInt throughout multiplication, division,
remainder calculation, and reversal. Since operands here are nonnegative,
JavaScript BigInt division agrees with mathematical floor division. Extending
to negative states requires a separately specified convention; BigInt truncation
and Python floor division otherwise differ.

At the very first step, \(Q\cdot399>2^{53}-1\). Binary64 computation of that
product gives 135639958766566416 instead of 135639958766566422. Even though the
quotient still happens to be 135, the remainder is then wrong by six. At the
largest 15-bit seed, \(Q\cdot32767=11139134157654340726\), which also exceeds
the signed 64-bit maximum. Small seeds do not imply safe intermediate products.

Parse user state text directly as an integer. In a browser use
`BigInt(decimalText)`, after validating the text, and never route it through
`Number` or `parseFloat`. If transported in JSON, represent exact integers as
canonical decimal strings. Retain the existing strict record parser and its
schema checks.

The accompanying JavaScript module is importable by browsers and Node. Its
verifier is a separate Node program. The small kernels are reference examples,
not replacements for the site's broader schema and UI validation. The current
tool also has a 100-digit input limit; this package does not change that policy.

## Local reproduction

No installation of external packages is needed. From the extracted directory:

```bash
python3 floor_kernel.py 399 --verify
python3 -O floor_kernel.py 399 --verify
node verify_floor_kernel.mjs
```

To compare with the exact public files retrieved for this inspection:

```bash
python3 floor_kernel.py 399 --verify --site-reference evidence/omega_reference_checker.py
node verify_floor_kernel.mjs --site-bridge evidence/bridge.js
```

The optional comparisons execute the included retrieved source. Review it
before running it, as with any downloaded program. The bridge comparison uses
the exports of this recorded build, not a promise about future minified export
names. The source URLs and hashes are recorded in `EVIDENCE.md`.

The record checksum format is ASCII
`seed|comma-separated-states|comma-separated-remainders` followed by one LF
byte per seed, with seeds ordered from 0 through 32767. It belongs to these
two new reference verifiers, not an existing site interchange contract.

## Verbatim directions for Grok

Implement a documentation and reproducibility improvement for the existing
rational-floor example. Do not infer or replace its mathematical map.

1. On `/tools/reconstruct` and `/start/shape-to-record`, show a visible
   "Exact rule" section immediately before the orbit table. State the decimal
   integers Q = 339949771344778 and S = 1000000000000000. Render
   F(d) = floor(Qd/S), rho(d) = Qd - S F(d), 0 <= rho(d) < S, and
   d = (S d_next + rho)/Q. Explain that the last expression requires exact
   divisibility. Show the full product decomposition for 399.

2. Include this exact explanatory sentence: "The step multiplies the state
   by Q/S and takes the floor. The remainder records the discarded fractional
   part multiplied by S; it is not an adjustment to division by three."

3. Beside the homepage's 399 example, link directly to `/dynamics#floor` and
   `/dynamics#reconstruction`. Retain the current sources and result table.
   Link the reconstruction tool directly to its downloadable code, not just
   to a general evidence page.

4. Host this note and the supplied code under `/dynamics/floor-kernel/`.
   Publish download links for `PROOF_AND_GROK_HANDOFF.md`, `floor_kernel.py`,
   `floor_kernel.mjs`, `verify_floor_kernel.mjs`, the three verification text
   files, `EVIDENCE.md`, `LICENSE-CODE`, and `SHA256SUMS.txt`. Also offer the
   intact ZIP. Add these links to `/reproduce`.

5. Keep the production BigInt arithmetic and existing record contracts. If
   code is refactored, have the page import the same production functions
   that acceptance tests execute. A second unconnected demonstration cannot
   certify the deployed functions. Keep scalar real-map illustrations separate
   from exact rational-floor computation.

6. Keep integer values as decimal strings in records. Reject invalid types,
   invalid remainder bounds, failed reverse divisibility, wrong map parameters,
   and forbidden extinction padding. Preserve the imported-record decoder's
   independence from the generator seed. Do not claim that every altered or
   truncated ledger must be rejected: a valid suffix encodes another seed.

7. Run the Python checker normally and under `-O`, and run the Node checker.
   Require the stated orbit, recovery of 399, all 32768 successful seed
   round trips, maximum extinction depth 10, and matching domain checksums.
   Test the deployed tool's 399 export and import using its production code.
   Record separately whether this was a module run or a browser test.

8. Preserve the distinction between the unpadded six-transition 399 ledger
   and older fixed-length padded contracts. Preserve the external h = 1/100
   display convention. Do not describe Q/S as exactly equal to lambda.

9. Generate actual byte counts and full hashes from the hosted files. Fetch
   each public artifact after deployment and verify its bytes against the
   attached checksum file. Extract the ZIP directly; do not rebuild Markdown
   from a rendered paste. Report the deployed page and artifact URLs.

10. Classify this as an explanatory and reproducibility supplement. Keep the
    existing paper count, DOIs, frozen certificates, and publication status.
    Do not claim a new theorem, third-party reproduction, or browser acceptance
    solely from these local checks.