goolge translate is terrible recently, its output is different everytime!
I am not sure the idea will be conveyed properly, esp. for those not familiar
with the Collatz Conjecture. If not, its my failure.
While looking back, the proof of Collatz Conjecture is unbelievably simple.
I think it is because: According to the Church–Turing conjecture (and my own
conjecture): No formal language has greater expressive power than procedural
language, particular C/C++ (just imagine that if this proof was made in
traditional formalism).
But the development of C is, IMO, 'average'. C++ 'may be' still superstitous
in their 'expressive' and 'useful'....
This file is intended a proof of Collatz Conjecture. The contents may be updated anytime. https://sourceforge.net/projects/cscall/files/MisFiles/Coll-proof-en.txt/download
The text is converted by google translate with modest modification from https://sourceforge.net/projects/cscall/files/MisFiles/Coll-proof-zh.txt/download
Reader might want to try different translator or different settings.
----------------------------------------------------------------------------- Collatz function ::=
int cop(int n) {
if(n<=1) {
return 1; // 1 is the iteration endpoint
}
if(n%2) {
return 3*n+1; // Odd number rule
} else {
return n/2; // Even number rule
}
}
Collatz number(n): If an integer n, n>=1, the cop iteration operation will
eventually calculate to 1 (i.e., cop(...cop(n))=1), then n is a Collatz
number.
Collatz Conjecture: For all integer n, n>=1, n is a Collatz number.
The cop operation can be managed to an ibp function is a combination of
(3n+1)/2 and n/2 operations. Each ibp operation is processed according to
the least significant bit (LSB) of n. 0 corresponds to the n/2 operation
and 1 corresponds to the two cop operations (3n+1)/2.
int ibp(int n) {
if(n<=1) {
return n; // 1 does not iterate
}
if(n%2) {
n= (3*n+1)/2; // Odd and even cop operations are considered as one
// ibp iteration
} else {
n/=2;
}
return n;
};
Let the bit sequence of n be abc. The ibp iteration result can be roughly
shown in the following figure ((3x+1)/2= x+⌊x/2⌋+1):
abc
1+ abc // x3+1 operation
1+ abc // If there is an even operation (i.e. n/2), delete a line
1+ abc
ABCXX // The state after ibp iteration: A,B,C represent the sum of
// bits related to a,b,c and carry. X represents carrys not
// directly related to a,b,c.
Let n=JK, J,K represent two consecutive base-2 numbers. Let |K|
represent the number of bits of the binary number of K, then after n goes
through |K| times of ibp operation process, the remaining J will be changed
to J' due to odd/even operations and carrys. However, the maximum value of
J' is approximately J*(3/2)^|K|. The maximum length of J' is approximately
log(J*(3/2)^|K|)= log(J)+ 0.4*|K|.
Prop: For any integer n, n>1, the iteration of the cop function of n will always
result in a number equal to 1.
Proof: Assume that all numbers with the bit length less than or equal to |n|
are Collatz numbers. Let the binary representation of n be 1ddd. 2n, 2n+1
be 1ddd# (# represents 0 or 1). Let the binary form of K be ddd#, J=1
(the most significant bit).
Assum J becomes J' after |K| ibp operations, |J'|= |J|+ 0.4*|K| =
1+ 0.4*|K|.
By assumption, if |J'|≤ |K|, then J' will be a Collatz number because
when |K|>=2, J' is also a Collatz number.
1+0.4*|K|≤ |K|
<=> 1 <= |K|- 0.4*|K|
<=> 1 <= 0.6*|K|
<=> 1/0.6 ≤ |K|
Thus, the cop iteration for integers 2n and 2n+1 will calculate to 1.
That is, all integers greater than 4 are Collatz numbers (since 1, 2,
and 3 are known to be Collatz numbers). -------------------------------------------------------------------------------
On 12/24/25 7:06 AM, wij wrote:
goolge translate is terrible recently, its output is different everytime!
I am not sure the idea will be conveyed properly, esp. for those not familiar
with the Collatz Conjecture. If not, its my failure.
While looking back, the proof of Collatz Conjecture is unbelievably simple.
I think it is because: According to the Church–Turing conjecture (and my own
conjecture): No formal language has greater expressive power than procedural
language, particular C/C++ (just imagine that if this proof was made in traditional formalism).
But the development of C is, IMO, 'average'. C++ 'may be' still superstitous
in their 'expressive' and 'useful'....
This file is intended a proof of Collatz Conjecture. The contents may be updated anytime. https://sourceforge.net/projects/cscall/files/MisFiles/Coll-proof-en.txt/download
The text is converted by google translate with modest modification from https://sourceforge.net/projects/cscall/files/MisFiles/Coll-proof-zh.txt/download
Reader might want to try different translator or different settings.
-----------------------------------------------------------------------------
Collatz function ::=
int cop(int n) {
if(n<=1) {
return 1; // 1 is the iteration endpoint }
if(n%2) {
return 3*n+1; // Odd number rule
} else {
return n/2; // Even number rule
}
}
Collatz number(n): If an integer n, n>=1, the cop iteration operation will eventually calculate to 1 (i.e., cop(...cop(n))=1), then n is a Collatz
number.
Collatz Conjecture: For all integer n, n>=1, n is a Collatz number.
The cop operation can be managed to an ibp function is a combination of
(3n+1)/2 and n/2 operations. Each ibp operation is processed according to
the least significant bit (LSB) of n. 0 corresponds to the n/2 operation
and 1 corresponds to the two cop operations (3n+1)/2.
int ibp(int n) {
if(n<=1) {
return n; // 1 does not iterate }
if(n%2) {
n= (3*n+1)/2; // Odd and even cop operations are considered as one
// ibp iteration } else {
n/=2;
}
return n;
};
Let the bit sequence of n be abc. The ibp iteration result can be roughly
shown in the following figure ((3x+1)/2= x+⌊x/2⌋+1):
abc
1+ abc // x3+1 operation
1+ abc // If there is an even operation (i.e. n/2), delete a line
1+ abc
ABCXX // The state after ibp iteration: A,B,C represent the sum of
// bits related to a,b,c and carry. X represents carrys not
// directly related to a,b,c.
So, (3x+1)/2 adds bits to the bottom that are some function of the
number, but "unkown" to your algorithm. Your resultant value is BIGGER
than your input number, and thus isn't consuming any of the bits like
you try to assume below.
Yes, the proof is flawed (no wonder I uncomfortably removed many other 'redundent' data) .... fixing.Let n=JK, J,K represent two consecutive base-2 numbers. Let |K| represent the number of bits of the binary number of K, then after n goes
through |K| times of ibp operation process, the remaining J will be changed
to J' due to odd/even operations and carrys. However, the maximum value of
J' is approximately J*(3/2)^|K|. The maximum length of J' is approximately
log(J*(3/2)^|K|)= log(J)+ 0.4*|K|.
And why do you think that after the |K| operations you are just left
with a J' that is of the order of J, it could be as big as
J * (3//2)**|K| and just |J'| = |J| + 0.4*|K| which, is significantly
bigger than J.
Your cycles do not "consume" the bits of K, they just continue to make a bigger number.
Prop: For any integer n, n>1, the iteration of the cop function of n will always
result in a number equal to 1.
Proof: Assume that all numbers with the bit length less than or equal to |n|
are Collatz numbers. Let the binary representation of n be 1ddd. 2n, 2n+1
be 1ddd# (# represents 0 or 1). Let the binary form of K be ddd#, J=1
(the most significant bit).
Assum J becomes J' after |K| ibp operations, |J'|= |J|+ 0.4*|K| =
1+ 0.4*|K|.
By assumption, if |J'|≤ |K|, then J' will be a Collatz number because
when |K|>=2, J' is also a Collatz number.
1+0.4*|K|≤ |K|
<=> 1 <= |K|- 0.4*|K|
<=> 1 <= 0.6*|K|
<=> 1/0.6 ≤ |K|
Thus, the cop iteration for integers 2n and 2n+1 will calculate to 1.
That is, all integers greater than 4 are Collatz numbers (since 1, 2,
and 3 are known to be Collatz numbers). -------------------------------------------------------------------------------
So, you started with 1..n as Collatz numbers, and showed that 2n, 2n+1 are.wij's theorems of natural number W:
What about n+1, n+2, ... 2n-1?
What you have shown is that there are an unbounded number of Collatz Numbers, not that all numbers are Collatz.--- Synchronet 3.21a-Linux NewsLink 1.2
On Wed, 2025-12-24 at 07:35 -0500, Richard Damon wrote:
On 12/24/25 7:06 AM, wij wrote:
goolge translate is terrible recently, its output is different everytime!
I am not sure the idea will be conveyed properly, esp. for those not familiar
with the Collatz Conjecture. If not, its my failure.
While looking back, the proof of Collatz Conjecture is unbelievably simple.
I think it is because: According to the Church–Turing conjecture (and my own
conjecture): No formal language has greater expressive power than procedural
language, particular C/C++ (just imagine that if this proof was made in
traditional formalism).
But the development of C is, IMO, 'average'. C++ 'may be' still superstitous
in their 'expressive' and 'useful'....
This file is intended a proof of Collatz Conjecture. The contents may be updated anytime. https://sourceforge.net/projects/cscall/files/MisFiles/Coll-proof-en.txt/download
The text is converted by google translate with modest modification from https://sourceforge.net/projects/cscall/files/MisFiles/Coll-proof-zh.txt/download
Reader might want to try different translator or different settings.
-----------------------------------------------------------------------------
Collatz function ::=
int cop(int n) {
if(n<=1) {
return 1; // 1 is the iteration endpoint }
if(n%2) {
return 3*n+1; // Odd number rule
} else {
return n/2; // Even number rule
}
}
Collatz number(n): If an integer n, n>=1, the cop iteration operation will
eventually calculate to 1 (i.e., cop(...cop(n))=1), then n is a Collatz
number.
Collatz Conjecture: For all integer n, n>=1, n is a Collatz number.
The cop operation can be managed to an ibp function is a combination of
(3n+1)/2 and n/2 operations. Each ibp operation is processed according to
the least significant bit (LSB) of n. 0 corresponds to the n/2 operation
and 1 corresponds to the two cop operations (3n+1)/2.
int ibp(int n) {
if(n<=1) {
return n; // 1 does not iterate }
if(n%2) {
n= (3*n+1)/2; // Odd and even cop operations are considered as one
// ibp iteration } else {
n/=2;
}
return n;
};
Let the bit sequence of n be abc. The ibp iteration result can be roughly
shown in the following figure ((3x+1)/2= x+⌊x/2⌋+1):
abc
1+ abc // x3+1 operation
1+ abc // If there is an even operation (i.e. n/2), delete a line
1+ abc
ABCXX // The state after ibp iteration: A,B,C represent the sum of
// bits related to a,b,c and carry. X represents carrys not
// directly related to a,b,c.
So, (3x+1)/2 adds bits to the bottom that are some function of the
number, but "unkown" to your algorithm. Your resultant value is BIGGER than your input number, and thus isn't consuming any of the bits like
you try to assume below.
Let n=JK, J,K represent two consecutive base-2 numbers. Let |K| represent the number of bits of the binary number of K, then after n goes
through |K| times of ibp operation process, the remaining J will be changed
to J' due to odd/even operations and carrys. However, the maximum value of
J' is approximately J*(3/2)^|K|. The maximum length of J' is approximately
log(J*(3/2)^|K|)= log(J)+ 0.4*|K|.
And why do you think that after the |K| operations you are just left
with a J' that is of the order of J, it could be as big as
J * (3//2)**|K| and just |J'| = |J| + 0.4*|K| which, is significantly bigger than J.
Your cycles do not "consume" the bits of K, they just continue to make a bigger number.
Yes, the proof is flawed (no wonder I uncomfortably removed many other 'redundent' data) .... fixing.
Prop: For any integer n, n>1, the iteration of the cop function of n will always
result in a number equal to 1.
Proof: Assume that all numbers with the bit length less than or equal to |n|
are Collatz numbers. Let the binary representation of n be 1ddd. 2n, 2n+1
be 1ddd# (# represents 0 or 1). Let the binary form of K be ddd#, J=1
(the most significant bit).
Assum J becomes J' after |K| ibp operations, |J'|= |J|+ 0.4*|K| =
1+ 0.4*|K|.
By assumption, if |J'|≤ |K|, then J' will be a Collatz number because
when |K|>=2, J' is also a Collatz number.
1+0.4*|K|≤ |K|
<=> 1 <= |K|- 0.4*|K|
<=> 1 <= 0.6*|K|
<=> 1/0.6 ≤ |K|
Thus, the cop iteration for integers 2n and 2n+1 will calculate to 1.
That is, all integers greater than 4 are Collatz numbers (since 1, 2,
and 3 are known to be Collatz numbers). -------------------------------------------------------------------------------
wij's theorems of natural number W:So, you started with 1..n as Collatz numbers, and showed that 2n, 2n+1 are.
What about n+1, n+2, ... 2n-1?
wij's theorems of natural number W:
A: 1 ∈ W
B: ∀n∈W, 2n,2n+1
Cantor's kind of theory of infinity is flawed somewhere.
But I can only do one thing at a time, so...
What you have shown is that there are an unbounded number of Collatz Numbers, not that all numbers are Collatz.
The cop operation can be managed to an ibp function is a combination of
(3n+1)/2 and n/2 operations. Each ibp operation is processed according to
the least significant bit (LSB) of n. 0 corresponds to the n/2 operation
and 1 corresponds to the two cop operations (3n+1)/2.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,090 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 59:51:25 |
| Calls: | 13,948 |
| Calls today: | 1 |
| Files: | 187,035 |
| D/L today: |
2,695 files (773M bytes) |
| Messages: | 2,461,296 |