# Ten-Step Fixed-Fiber Audit For n = 1980976057694848447

This file is not a step-by-step ordinary orbit list. It is a fixed-fiber ledger audit.

The point of the file is narrow: it writes out the 10 displayed fiber-ledger steps with the exact arithmetic used at each step. A fixed-fiber row is never treated as the next ordinary odd iterate of the preceding row.

## Maps

For odd n, define the ordinary accelerated odd Collatz map:

    T_odd(n) = (3n + 1) / 2^v2(3n + 1).

For a fixed fiber coordinate q, define its assigned odd representative:

    m_entry(q) = 2q - 1.

Then:

    3*m_entry(q) + 1
    = 3(2q - 1) + 1
    = 6q - 2
    = 2(3q - 1).

So if:

    3q - 1 = 2^r * c,

then:

    T_odd(m_entry(q)) = c.

This is the arithmetic checked in each fixed-fiber row below.

## The Non-Ordinary Rule Used Here

The fixed-fiber ledger rule is:

    fixed fiber q_in = q
        -> assigned representative m_entry = 2q - 1
        -> ordinary step from that representative gives c = T_odd(m_entry)
        -> next recorded fiber is q_in = c.

Rows 1-4 use exactly that recording convention. Row 5 is different only because
it opens the displayed 11 mod 64 case: after producing c, it writes c in its
ordinary L = 1 break-state form c + 1 = 2q and continues with that q.

This is not the ordinary-orbit rule:

    current ordinary odd state m
        -> next ordinary odd state T_odd(m).

The ordinary-orbit rule and the fixed-fiber ledger rule are different rules. This file audits the second rule numerically.

## Coordinate Boundary

There are two related coordinate readings, and this file keeps them separate.

For an odd break-state value m, one can write:

    L = v2(m + 1),
    q_break = (m + 1) / 2^L,
    m = 2^L q_break - 1.

That is the ordinary break-state reading of m.

The fixed-fiber ledger used below is different. It starts from a recorded ledger
coordinate q and assigns the L = 1 representative:

    m_entry(q) = 2q - 1.

Then it applies the ordinary accelerated map to that assigned representative:

    q -> m_entry(q) -> T_odd(m_entry(q)).

For this file, the starting ordinary computation gives:

    T_odd^6(n0) = 11282277703590191551.

This odd value is used as the first recorded ledger coordinate:

    q0 = 11282277703590191551.

This is not the same as the break-state coordinate of that odd value. Indeed:

    11282277703590191551 + 1
    = 2^6 * 176285589118596743.

So the ordinary break-state coordinate would be:

    q_break = 176285589118596743.

The fixed-fiber ledger in this file instead audits the assigned representative
for the recorded ledger coordinate q0:

    m_entry(q0) = 2q0 - 1 = 22564555407180383101.

## Entry Number

For the original odd integer:

    n0 = 1980976057694848447.

Direct ordinary computation gives:

    T_odd^1(n0) = 2971464086542272671
    T_odd^2(n0) = 4457196129813409007
    T_odd^3(n0) = 6685794194720113511
    T_odd^4(n0) = 10028691292080170267
    T_odd^5(n0) = 15043036938120255401
    T_odd^6(n0) = 11282277703590191551

The 10-step fixed-fiber ledger starts from the fiber coordinate:

    q0 = 11282277703590191551.

The next line is therefore not computed as T_odd(q0). It is computed from the assigned representative:

    m_entry(q0) = 2q0 - 1 = 22564555407180383101.

## Four Fixed-Fiber Rows

Each of the following rows checks this identity:

    3q - 1 = 2^r * c,
    T_odd(2q - 1) = c.

### Row 1

    q_in = 11282277703590191551
    m_entry = 2q_in - 1 = 22564555407180383101
    3q_in - 1 = 33846833110770574652 = 2^2 * 8461708277692643663
    3*m_entry + 1 = 67693666221541149304 = 2^3 * 8461708277692643663
    T_odd(m_entry) = 8461708277692643663
    v2(8461708277692643663 + 1) = 4
    next fiber q_in = 8461708277692643663

Ordinary-orbit comparison from q_in itself:

    T_odd(11282277703590191551) = 16923416555385287327

So this row is visibly a fixed-fiber row, not ordinary continuation from q_in.

### Row 2

    q_in = 8461708277692643663
    m_entry = 2q_in - 1 = 16923416555385287325
    3q_in - 1 = 25385124833077930988 = 2^2 * 6346281208269482747
    3*m_entry + 1 = 50770249666155861976 = 2^3 * 6346281208269482747
    T_odd(m_entry) = 6346281208269482747
    v2(6346281208269482747 + 1) = 2
    next fiber q_in = 6346281208269482747

Ordinary-orbit comparison from q_in itself:

    T_odd(8461708277692643663) = 12692562416538965495

### Row 3

    q_in = 6346281208269482747
    m_entry = 2q_in - 1 = 12692562416538965493
    3q_in - 1 = 19038843624808448240 = 2^4 * 1189927726550528015
    3*m_entry + 1 = 38077687249616896480 = 2^5 * 1189927726550528015
    T_odd(m_entry) = 1189927726550528015
    v2(1189927726550528015 + 1) = 4
    next fiber q_in = 1189927726550528015

Ordinary-orbit comparison from q_in itself:

    T_odd(6346281208269482747) = 9519421812404224121

### Row 4

    q_in = 1189927726550528015
    m_entry = 2q_in - 1 = 2379855453101056029
    3q_in - 1 = 3569783179651584044 = 2^2 * 892445794912896011
    3*m_entry + 1 = 7139566359303168088 = 2^3 * 892445794912896011
    T_odd(m_entry) = 892445794912896011
    v2(892445794912896011 + 1) = 2
    next fiber q_in = 892445794912896011

Ordinary-orbit comparison from q_in itself:

    T_odd(1189927726550528015) = 1784891589825792023

At this point the fixed-fiber ledger has reached:

    892445794912896011 = 64 * 13944465545514000 + 11.

## Opening This 11 mod 64 Case

### Row 5

Use the same fixed-fiber arithmetic with:

    q = 892445794912896011.

Then:

    m_entry = 2q - 1 = 1784891589825792021
    3q - 1 = 2677337384738688032 = 2^5 * 83666793273084001
    3*m_entry + 1 = 5354674769477376064 = 2^6 * 83666793273084001
    T_odd(m_entry) = 83666793273084001
    83666793273084001 + 1 = 2 * 41833396636542001

The fixed-fiber output is:

    c = 83666793273084001.

Opening this output as an ordinary L = 1 break-state gives:

    q = 41833396636542001.

### Row 6

Here the assigned representative of this new q is exactly the previous output c:

    m_entry = 2q - 1 = 83666793273084001.

Compute:

    q = 41833396636542001
    3q - 1 = 125500189909626002 = 2^1 * 62750094954813001
    3*m_entry + 1 = 251000379819252004 = 2^2 * 62750094954813001
    T_odd(m_entry) = 62750094954813001
    62750094954813001 + 1 = 2 * 31375047477406501

From here the displayed calculation continues from the produced odd state:

    m = 62750094954813001.

## Local Break-State Continuation Below n0

For an odd break-state value m, set:

    L = v2(m + 1),
    q = (m + 1) / 2^L,
    m_next = (3^L q - 1) / 2^v2(3^L q - 1).

### Row 7

    m = 62750094954813001
    L = v2(m + 1) = 1
    q = 31375047477406501
    3^L q - 1 = 94125142432219502 = 2^1 * 47062571216109751
    m_next = 47062571216109751
    v2(m_next + 1) = 3

### Row 8

    m = 47062571216109751
    L = v2(m + 1) = 3
    q = 5882821402013719
    3^L q - 1 = 158836177854370412 = 2^2 * 39709044463592603
    m_next = 39709044463592603
    v2(m_next + 1) = 2

### Row 9

    m = 39709044463592603
    L = v2(m + 1) = 2
    q = 9927261115898151
    3^L q - 1 = 89345350043083358 = 2^1 * 44672675021541679
    m_next = 44672675021541679
    v2(m_next + 1) = 4

### Row 10

    m = 44672675021541679
    L = v2(m + 1) = 4
    q = 2792042188846355
    3^L q - 1 = 226155417296554754 = 2^1 * 113077708648277377
    m_next = 113077708648277377
    v2(m_next + 1) = 1

Finally:

    113077708648277377 < 1980976057694848447 = n0.

## What Is Being Audited

This file audits the fixed-fiber ledger calculation:

    q_in -> m_entry(q_in) = 2q_in - 1 -> T_odd(m_entry(q_in)) -> next q_in.

It does not ask the reader to confuse that with ordinary continuation from q_in itself. The ordinary comparison values in rows 1-4 are included precisely to show the two rules are different.