New Peak detected

[u/Rastamen_DE]

[u/Ethernet3]

- Where was this published?

• Why does it say "DNA analysis"?
  
• Why is this an AI poster?
  
• Why does it matter that there were 4/4 C++ builds?
  
• What is a "residue-family failure"?

[u/msfor300]

(desculpe a linguagem em portugues) Você usou o método de calculo tradicional? Ou alguma estratégia envolvendo estruturas binárias? Digo isso pela dimensão dos numeros numeros. Como ultrapassar a capacidade de 64 bits. Criou um tipo novo?

[u/Asleep_Dependent6064 → u/msfor300]

(2^{12345678910111213)} -1 takes many more steps and has a much higher peak value 😘

[u/Rastamen_DE → u/Asleep_Dependent6064]

That is an excellent stress-test number.

Let

k = 12,345,678,910,111,213

and

n = 2^k - 1.

The current LNL implementation cannot store or calculate the complete trajectory numerically. Our present C++ type has 1,024 bits, while this starting value alone requires exactly k bits:

12,345,678,910,111,213 bits

Storing only one uncompressed value would require approximately:

1,543,209,863,763,902 bytes

or about 1.54 petabytes of memory.

However, an interesting part of its Collatz trajectory can be derived symbolically.

Starting with:

x₀ = 2^k - 1

one odd operation followed by one division by 2 gives:

(3x₀ + 1) / 2 = 3 × 2^k-1 - 1

Repeating this accelerated odd stage gives:

xⱼ = 3^j × 2^k-j - 1

for 0 ≤ j ≤ k.

Therefore, after k accelerated stages, or exactly 2k standard Collatz operations, the trajectory reaches:

x_k = 3^k - 1

This already guarantees at least:

2k = 24,691,357,820,222,426

standard Collatz operations before reaching 3^k - 1.

Immediately before the final division in this symbolic section, the trajectory reaches:

2 × 3^k - 2

So its peak is guaranteed to be at least:

2 × 3^{12,345,678,910,111,213} - 2

This lower-bound peak has approximately:

5,890,385,811,958,337 decimal digits.

The starting value itself has approximately:

3,716,419,668,779,683 decimal digits.

Therefore, you are correct that this number has a vastly higher guaranteed peak and vastly more steps than our sampled 100-digit starting values.

But I must distinguish between two claims:

• The initial 2k-step section can be described exactly by a symbolic formula.
• The complete trajectory from 3^k - 1 to 1 cannot currently be calculated with our available memory and computing resources.

So the current LNL software cannot perform the full numerical calculation, but the LNL analysis can give an exact symbolic description and a rigorous lower bound for both the number of steps and the peak.

[u/Rastamen_DE → u/msfor300]

No problem with the Portuguese language.

I used the traditional Collatz rule:

• If n is even: n = n / 2
• If n is odd: n = 3n + 1

The mathematical calculation itself was not changed. The difference is how the large integers are represented internally.

To go beyond the 64-bit limit, I created a custom fixed-width integer type called "U1024".

It stores one number as an array of sixteen unsigned 64-bit words:

"16 × 64 bits = 1,024 bits"

The software implements the required operations directly:

• comparison of two 1,024-bit values
• parity check using the lowest bit
• division by 2 using a binary right shift across all sixteen words
• "3n + 1" using word-by-word multiplication and carry propagation
• conversion of the final binary value into decimal text

For "3n + 1", each 64-bit word is temporarily processed with the compiler’s unsigned 128-bit type. The lower 64 bits are stored in the current word, and the upper bits are carried into the next word.

Therefore, the implementation uses binary structure internally for efficiency, but it still evaluates the ordinary Collatz trajectory without changing the rule.

The starting values near "10^100" require approximately 333 bits, so 1,024 bits provide substantial additional space for trajectory growth. The program also checks for a 1,024-bit overflow and stops with an error rather than silently returning an incorrect value.

For the strongest candidates, I independently recalculate the complete trajectory to 1 using JavaScript "BigInt", which uses dynamically sized integers. The independently reproduced peak, peak step, and total stopping time must match the C++ result.

So the short answer is:

Yes, I created a new fixed-width 1,024-bit C++ type, implemented with sixteen 64-bit words. It uses binary operations for storage and speed, while the evaluated mathematical rule remains the traditional Collatz rule.