コラッツ予想がとけたらいいな

**１３２人目の素数さん** · 2012/10/14(日) 10:32:39.71

525 名前：１３２人目の素数さん[sage] 投稿日：2012/09/03(月) 18:24:27.22
http://d.hatena.ne.jp/righ1113/
コラッツ予想について、証明を考えてみました。
ご指摘ご意見ご感想など、ぜひよろしくお願いします。

**１３２人目の素数さん** · 2014/09/08(月) 15:17:54.23

>>173
0の個数のルールは分かった。だがLnが何なのか分からんｗ

＞sステップ後値の初期値0位置からの距離をLlとおきましょう。
＞例の5ステップ目はLl=6となります。

「後値」とは何なのか？
「初期値0位置」とはどこなのか？
「初期値0位置からの距離」とは何なのか？――たとえば、a000b という
文字列があったとして、「文字aから文字bまでの距離」とは、
距離の測定の仕方によって「距離は4」とも言えるし「距離は5」とも言える。
つまり、単に「距離」と書いただけでは意味が定まらない。
あと、「例の5ステップ目」とあるが、ステップのカウントの仕方が
書いてないから意味が定まらない。具体的に言えば、一番最初の
「 111　　　　7 」を「0ステップ目」とカウントしているのか
「1ステップ目」とカウントしているのか全く不明。

ついでに、>>88も意味がわからんｗ
＞00000111
＞000010101
＞000111111
＞0010111101
＞01110110001
＞10100101011
なぜ一番最初に00000が補完してあるのか？なぜ2行目に0000が補完してあるのか？
補完する個数のルールは何なのか？LlもLnと全く同様に意味がわからん。

**righ1113** · 2014/09/08(月) 21:26:14.95

http://cdn-ak.f.st-hatena.com/images/fotolife/r/righ1113/20140908/20140908212210.jpg

図に書いてみました。
わかりますでしょうか……

**１３２人目の素数さん** · 2014/09/09(火) 18:54:12.57

>>175
把握した。
このルールだと、コラッツ値が 1 に到達してから先のステップでは、
Ln(s)－Ll(s) はどんどん大きくなって＋∞に発散してしまうわけだが、
ということは、コラッツ値が 1 になるまでの s だけを考えるということか？

あと、>>175をよく見ると、>>99のリンク先には無いパターンがあり、>>99は不完全ということになる。
まず、>>99のリンク先では、ずれが生じているステップ(赤い「1」が存在する行)が3箇所あり、それは

s　 …00001　…1111　(←「特定のパターン1つ目」のもの。「ずれパターン1」と名づける)

s　 …00001　…11011 (←「特定のパターン2つ目」のもの。「ずれパターン2」と名づける)

s '　…1001　 …1111　(←「特定のパターン2つ目」のもの。「ずれパターン3」と名づける)

となっている(>>99の図で空白のマスになっている部分は、ここでは「…」で表現した)。
一方で、>>175では、s = 2 のときに最初のずれが生じ、そのときのパターンは、上の表記法に合わせると

s　 …10001　…1111

となっている。「10001」の部分は、上記の「ずれパターン1,2,3」のいずれでもない。
同じく、>>175では、s = 5 のときに2回目のずれが生じ、そのときのパターンは

s　 …00001　…01011

となっている。「01011」の部分は、上記の「ずれパターン1,2,3」のいずれでもない。
また、>>99では、「ずれパターン1」の場合は、一度ずれたら、その後の3ステップはずれないことになっている。
「ずれパターン2」の場合は、直後の1ステップはずれなくて、その後のステップで再びずれることになっている。
しかし、>>175では、s = 2 が「ずれ」, s = 3, 4 が「ずれなし」, s = 5 が「ずれ」ということなので、
ずれないステップ数が2ステップであり、>>99のどのパターンにも合致しない。

**righ1113** · 2014/09/09(火) 21:22:44.68

そうです。コラッツ値が1になるまでのsを考えます。

「10001」の部分は少し考えさせてください。

s=5のときはコラッツ値が1になっているので考えないです。

**１３２人目の素数さん** · 2014/09/10(水) 02:02:20.13

>>177
追い討ちをかける形になってしまうが、
多倍長整数を使ってプログラムを組んで実験したら、さらにマズイ例が見つかった。

初期値が 27 のとき、コラッツ値が 1 になるまでの範囲でずれが生じるステップは s = 14, 26, 31, 38, 41 の5回のみ。
s = 41 でコラッツ値が 1 になるので、s = 41 は無視することにする。問題は s = 31 のときであり、s = 31 のときは

コラッツ値＝ 110000000001 (2進法, 左が下位バイト, 10進法では2051)
伸ばすやつ＝ 100100010100110000001000110011110111001111111100110111 (2進法, 左が下位バイト, 10進法では 27 * 3^31)

となっている。すなわち、

s　 …00001　…10111　(☆)

となっている。「10111」の部分は、「ずれパターン1,2,3」のいずれでもない。なお、このときのコラッツ値は10進法で2051であり、
まだ 1 に到達してないので、無視できない。[続く]

**１３２人目の素数さん** · 2014/09/10(水) 02:06:38.16

[続き]
さらに、実は直前の s = 30 のときも問題が起きている。s = 30 のときは

コラッツ値＝ 11101010101 (2進法, 左が下位バイト, 10進法では1367)
伸ばすやつ＝ 11000001110111010101101001100101111101111111110111001 (2進法, 左が下位バイト, 10進法では 27 * 3^30)

となっている。すなわち、s = 31 と置けば

s - 1　 …0101　…1001　(★)

となっている。s = 31 ではずれが起きていたから、そのことと上記の(★)を>>99に照らし合わせると、
上記の(★)は「特定のパターン2つ目」「ずれパターン2の直前(青いマスに「10」が書いてある行)」に該当するはず。
そうなると、s = 31 のときは、>>99によれば

s　 …00001　…11011

でなければならないが、実際には >>178の(☆) だったから合ってない。すなわち、やっぱり>>99はおかしい。
ついでに言うと、(★)が「特定のパターン2つ目」「ずれパターン2の直前(青いマスに「10」が書いてある行)」であるのなら、
s = 31 及び s ' = 33 においてずれが生じることになるが、s = 31 はともかく、「33」の方では実際にはずれが生じなくて、
s = 38 にならないとずれない。

なお、上記のデータはプログラム以外にも「手作業＆ wolfram alpha 」でも
チマチマ計算して確認したから間違いないはず。

**righ1113** · 2014/09/10(水) 02:26:36.71

計算ありがとうございます。
困りましたね……

**１３２人目の素数さん** · 2014/09/10(水) 02:29:12.07

一応、補足しておくと、s = 30, 31 のときの、「コラッツ値」に補正する0の個数は「12個」になっている。
「伸ばすやつ」は、左端からs個だけ切り捨てるから、結局、

s = 30
00000000000011101010101　( コラッツ値(補正版) )
01111101111111110111001　( 伸ばすやつ(補正版) )

s = 31
000000000000110000000001　( コラッツ値(補正版) )
10111001111111100110111　 ( 伸ばすやつ(補正版) )

となり、s = 31 でずれていることが分かる。
また、s = 30 は、>>99における「特定のパターン2つ目」「ずれパターン2の直前(青いマスに「10」が書いてある行)」
であるはず(しかし、s >= 31 の領域で結果が合わない)。

**１３２人目の素数さん** · 2014/09/10(水) 02:31:20.00

あっ、既に>>130にコメントがあった (´・ω・｀) スマソ

**１３２人目の素数さん** · 2014/09/10(水) 02:34:37.43

>>130じゃなくて>>180だったｗ (´・ω・｀) スマソ

**righ1113** · 2014/09/10(水) 03:03:17.86

ひとまず考えた事は、指摘2パターンも特定のパターンに加える事です。
そうすれば>>97も有効のままで問題も解消されるはず。

**１３２人目の素数さん** · 2014/09/10(水) 22:17:26.07

>>184
ただ単に「特定パターンに加えました」っていうだけだと、何も問題は解消されない。
なぜなら、まだパターンの抜けがあるかもしれないから。
それらの「特定のパターン」によって全てのパターンがちゃんと網羅できているのかを、
数学的に厳密に証明しなくちゃいけない。
もちろん、新しく加えた「特定のパターン」が>>97 の構造を壊すようなら失敗だ。

まあ、その前に、「特定のパターン」を全て列挙し直すところから出発かな。

**righ1113** · 2014/09/11(木) 02:00:43.36

そうですよねえ……

**righ1113** · 2014/09/13(土) 15:34:46.92

証明を戻して、>>89に改良を加えたものにします。
2つのパターンがずれるステップをsとおきます。
s-1でコラッツパターンが01、左端を伸ばすパターンが01の時は、
>>89の図の通り、s+1ステップでずれはなくなります。

**righ1113** · 2014/09/13(土) 15:36:13.96

s-1でコラッツパターンが11、左端を伸ばすパターンが01の時は、
（>>93の指摘にもありました）
まず左端を伸ばすパターンは
*1001　　　　s-1
11011　　　　s
*00101
**1111
***1101
*******1　　　　s+4
こうなります。

コラッツパターンの最大パターンは
*1111　　　　s-1
101101　　　　s
**10001
*101011
***00101
****1111　　　　s+4
となります。
s+4ステップでずれはなくなります。

**１３２人目の素数さん** · 2014/09/13(土) 19:17:45.25

>>187
このケースは大丈夫っぽい。

>>188
左端を伸ばすパターンの1行目がいきなり

＞ *1001　　　　s-1

となっているが、これはどうして？
**101 とか 10001 とかの場合は考えなくていいの？
(***11の場合は考えなくてよい、ということは分かるが…)

**１３２人目の素数さん** · 2014/09/15(月) 00:12:11.82

これって３ｎ＋１倍の操作を続けるといつかは２のべき乗にぶち当たるっていうことですか？

**righ1113** · 2014/09/15(月) 18:07:18.06

>>189
説明不足ですみませんが、コラッツパターンは最大、左端を伸ばすパターンは最小を調べています。
それでずれがなくなるなら、他のパターンでもずれがなくなるはずですから。
よって**101は*1001より大きいので除外です。
10001はs-2ステップが定義できないので除外です。

>>190
そういう事ではないです。コラッツパターンと左端を伸ばすパターンのずれが最大でも1である事を言っています。

**１３２人目の素数さん** · 2014/09/15(月) 19:44:19.31

>>191
「最大パターン」と「最小パターン」の意味がよく分からない。
最大・最小というからには、何か指標 X が予め定義されていて、
その指標 X が最大値を取るパターン・最小値を取るパターンについてのみ
考えるということなのだろうが、ここで言う X は何なの？

＞10001はs-2ステップが定義できないので除外です。
ここもよく分からない。コラッツパターンを無視して、
左端をのばすやつだけを観察すると、どんな初期値に対しても、

「右端に10001が出現するようなステップが無限回でてくる」

ことが証明できる。そのようなステップのうち、2より大きいものを任意に取ってtとするとき、
s = t + 2 に対して、「s-2ステップで10001になっている」と言える。
もちろん、このときのsに対して、コラッツパターンがs-1で11になっているとは限らないが、
少なくとも「除外」とまでは言えないだろう。それとも、何か深い理由があるのかな。

**righ1113** · 2014/09/16(火) 06:30:00.53

ずれた時のコラッツ値が最大、最小パターンのみを考えるということです。

10001については勘違いしてました。調べなきゃだめですね……

**１３２人目の素数さん** · 2014/09/16(火) 18:02:30.11

>>193
この方針では「証明できそうにない」ことが分かった。

まず、コラッツパターンの最大値について。>>188では、コラッツパターンの計算が

＞101101　　　　s

となっているが、これは間違っている。なぜなら、省略されている「*」の状況によっては
「111101」となる可能性があるからだ。コラッツパターンの最大値を考えるなら、採用すべきは
「101101」ではなく「111101」だろう。そして、「111101」が確実に起こるのは、
コラッツパターンが s-1 で *111111 となっている場合だ。
この考え方を突き詰めていくと、*1111 は最大値ではなく、*111111111 も最大値ではなく、
*1111111111111111111111111 も最大値ではない。理想的には

……1111 (左に向かって永遠に1が続く)

が最大値となる。しかし、実際には有限桁で終わるものしか考えないので、
結局、コラッツパターンに最大値は無い。
とはいっても、上記の理想的な場合について計算することは無意味ではない。
この場合、計算の仕方は「×3を繰り返す」だけでよく、
「＋1」は必要ない(というか、左末尾が無いので、どの桁にも「＋1」が適用できない)。
(続く)

**１３２人目の素数さん** · 2014/09/16(火) 18:05:29.22

(続き)
次に、左端を延ばすパターンの最小値について。*1001 は最小値ではなく、
*10001も最小値ではなく、*1000000000000000000000001 も最小値ではない。
理想的には

……0001 (左に向かって永遠に0が続く)

が最小値となるが、実際には有限桁で終わるものしか考えないので、
結局、左端を延ばすパターンに最小値は無い。
とはいっても、上記の理想的な場合について計算することは無意味ではない。
この場合、計算の仕方は「×3を繰り返す」だけでよい。
これらの設定のもとで計算をすると、残念ながら

「常にギリギリ1だけずれた状態で、永遠にずれが解消されない」(★)

ことが証明できる。従って、理想的な場合についての計算では、証明に失敗する。
(続く)

**１３２人目の素数さん** · 2014/09/16(火) 18:10:53.06

(続き)
実際には有限桁のものしか考えないので、有限桁の場合について考え直す必要がある。
コラッツパターンには最大値がなく、左端を伸ばすパターンには最小値が無いので、
コラッツパターン・左端を伸ばすパターンともに「任意の有限桁」を考えることになり、
つまりは無限通りある全てのパターンについて、いちいち個別に議論しなければならない。
実際には、「出来るだけ大きな、任意の有限桁」についてのみ考えればよいだろう。
この場合に問題となるのは、コラッツパターンの方である。上記の理想的な場合では、
「＋1」の操作は無視できたが、有限桁の場合だと、ちゃんと「＋1」の操作を考慮に
入れなければならない。

さて、コラッツパターン・左端を伸ばすパターンともに、「出来るだけ大きな有限桁」を
任意に取ろう。すなわち、

コラッツパターン：*111111111111111111111111111111111111111111111111111111111111111111111　(☆)
左端を延ばすやつ：*000000000000000000000000000000000000000000000000000000000000000000001　(☆)

のようなイメージである。この状態で計算をすると、初めの方のステップでは、
「＋1」の影響がまだ出てなくて、理想的な場合と計算結果はほとんど変わらない。
特に、右端付近の0と1の並び方は、理想的な場合と完全に一致する(★★)。
ということは、(★)と(★★)により、もしずれが解消されるとしても、
そのタイミングは「かなり遅い」ということになる。
(続く)

**１３２人目の素数さん** · 2014/09/16(火) 18:17:19.55

ずれた… 訂正。

コラッツパターン：*111111111111111111111111111111111111111111111111111111111111111111111　(☆)
左端を延ばす　：*000000000000000000000000000000000000000000000000000000000000000000001　(☆)

(続き)
というわけで、「せいぜい s＋4 あたりで、必ずずれが解消される」などというわけにはいかない。
上記の(☆)において、桁数を多く取れば取るほど、ずれが解消されるタイミングを好きなだけ
「遅く」出来てしまうのだ。

しかし、本当の問題はここでは無い。

ずれが解消されるタイミングが「かなり遅い」のであれば、その頃には「＋1」の影響が無視できなくなり、
理想的な場合とは計算結果に狂いが生じてくる。より具体的には、コラッツパターンの方は、
「＋1」の影響により、理想的な場合よりも僅かに桁数の増え方が大きくなることが予想される。
そうなると、想定していたタイミングでは「ずれが解消されない」ということが起こり得る。
もっと悪いのは、「むしろずれが増大する」という可能性である。

このような状況は、実際に起こり得る。たとえば、もし 1→4→2→1 以外のループが存在するならば、
そのループにおいては、明らかに「ずれがどんどん増大する」ことが分かる。
そして、ずれが増大するメカニズムは、「ループするから」という理由のほかに、

「『＋1』の影響が無視できなくなり、そこで計算結果に狂いが生じてくるから」

とも説明できる。こうなってくると、「ずれが解消される」ことを証明するよりも前に、まず
「ループが 1→4→2→1 以外に無い」ことを証明しなければならなくなり、本末転倒となる。

というわけで、この方針では、まず間違いなく、証明できないと思われる。

**righ1113** · 2014/09/17(水) 03:05:39.77

詳細な説明ありがとうございます。
どうしましょう……

**righ1113** · 2014/09/24(水) 20:57:41.32

コラッツパターンと左端を伸ばすパターンがずれるステップをsとおきます。
このとき、左端を伸ばすパターンのLl(s-1)=Ll(s)は、
　Ll(s-1)=[log(x0)+(s-1)*log(3/2)]
　Ll(s)=[log(x0)+s*log(3/2)]　　です。
Ll(s-1)にlog(3/2)を足しても整数部分は変わらないので、
log(x0)+(s-1)*log(3/2)の小数部分は.0以上1-log(3/2)（≒.415）未満です。
また、
　Ln(s-1)=[log(x0)+(s-1)*log(3/2)+log(1+1/3x0)…(1+1/3x(s-2))]
で、Ln(s-1)=Ll(s-1)ですから、
　0 < log(1+1/3x0)…(1+1/3x(s-2)) < log(3/2)　　が成り立ちます。
s-1の
コラッツパターンの式はx0*(3/2)^(s-1)*(1+1/3x0)…(1+1/3x(s-2))で
左端を伸ばすパターンの式はx0*(3/2)^(s-1)なので、
コラッツパターンは左端を伸ばすパターンの1.5倍未満ということになります。

s-1のコラッツパターンの最大値は　…11111で
左端を伸ばすパターンの最小値は　…00001でしたが、
これに1.5倍の制限がかかって
　コラッツパターン：…11111　　左端を伸ばすパターン：…10101
　コラッツパターン：…00011　　左端を伸ばすパターン：…00001
になります。

**righ1113** · 2014/09/24(水) 21:11:41.10

　コラッツパターン：…11111　　左端を伸ばすパターン：…10101
　コラッツパターン：…00011　　左端を伸ばすパターン：…00001
の遷移は
11111　　s-1
111101　　s
1110001　　s+1
1101011　　s+2

10101　　s-1
11111　　s
111101　　s+1
1110001　　s+2

00011　　s-1
001001　　s
011011　　s+1

00001　　s-1
00011　　s
001001　　s+1
となって、どちらもずれはなくなります。

**１３２人目の素数さん** · 2014/09/25(木) 17:28:56.49

>>199
＞0 < log(1+1/3x0)…(1+1/3x(s-2)) < log(3/2)　　が成り立ちます。
ここが間違ってる。

log(1+1/3x0)…(1+1/3x(s-2)) ≧ log(3/2)

の可能性もある。たとえば、log(x0)+(s-1)*log(3/2) の小数部分が「0.000000001未満」であって、しかも

0.9 ＞ log(1＋1/3x0)…(1＋1/3x(s－2)) ≧ log(3/2)

であるようなケースを考えると、Ll(s-1)=Ll(s)も成り立つしLn(s-1)=Ll(s-1)も成り立つ。

**１３２人目の素数さん** · 2014/09/25(木) 17:38:33.49

具体例は必要ないかもしれんが、一応。

log(x0)+(s-1)*log(3/2)＝2014.0000000001…
log(1+1/3x0)…(1+1/3x(s-2))＝0.80…

というケースがあったとすると、

0.9 ＞ log(1＋1/3x0)…(1＋1/3x(s－2)) ＞ log(3/2)

であり、しかも

Ll(s-1)＝[log(x0)+(s-1)*log(3/2)]＝[2014.0000000001…]＝2014
Ll(s)＝[log(x0)+s*log(3/2)]＝[2014.0000000001…＋0.5849625…]＝2014
Ln(s-1)＝[log(x0)+(s-1)*log(3/2)+log(1+1/3x0)…(1+1/3x(s-2))]＝[2014.0000000001…＋0.80…]＝2014

となる。すなわち、Ll(s-1)=Ll(s)も成り立つしLn(s-1)=Ll(s-1)も成り立つ。

何か他の事情により、このようなケースが実際には起こらない可能性もあるが、
その場合は、そのことを証明しなければならない。

**righ1113** · 2014/10/06(月) 02:41:44.94

すぐにはできそうにないです。

**１３２人目の素数さん** · 2014/10/06(月) 21:05:00.89

知ってた

**１３２人目の素数さん** · 2014/10/14(火) 16:46:04.01

ここに書かずにarxivに投稿すればいいのに

**righ1113** · 2014/10/19(日) 19:44:27.14

2chで穴を埋めてからarxivに投稿しようかな、と考えています。

**righ1113** · 2014/12/01(月) 21:07:16.64

ステップをさかのぼるとうまくいくのではないかと、まだ考え中です。

**righ1113** · 2014/12/06(土) 18:31:07.59

今日こたつを出しました。

**righ1113** · 2014/12/06(土) 19:12:58.62

コラッツパターンと左端を伸ばすパターンがずれるステップをsとおきます。
このとき、左端を伸ばすパターンのLl(s-1)=Ll(s)は、
　Ll(s-1)=[log(x0)+(s-1)*log(3/2)]
　Ll(s)=[log(x0)+s*log(3/2)]　　です。
Ll(s-1)にlog(3/2)を足しても整数部分は変わらないので、
log(x0)+(s-1)*log(3/2)の小数部分は.0以上1-log(3/2)（≒.415）未満です。

これを.0～.17と.17～.415に分けます。
.17～.415は
　Ln(s-1)=[log(x0)+(s-1)*log(3/2)+log(1+1/3x0)…(1+1/3x(s-2))]
で、Ln(s-1)=Ll(s-1)ですから、
　0 < log(1+1/3x0)…(1+1/3x(s-2)) < 0.83　　が成り立ちます。
　0 < Ax(s-2) < 0.83　　とします。

**righ1113** · 2014/12/06(土) 20:51:19.71

.0～.17と.17～.415のコラッツ値をy,xとおいて、ステップをさかのぼると、
Ays、Axsは単調増加なので、どこかで両方が0.7を下回ります。
そのステップをtとおきます。
　Ayt < 0.7、Axt < 0.7　　です。

**righ1113** · 2014/12/07(日) 19:05:07.95

　Ay(t-1) < 0.7、Ax(t-1) < 0.7　　でした。
　Ax(t-1) + log(1+1/3xt)…(1+1/3x(s-2)) = Ax(s-2)なので
　log(1+1/3xt)…(1+1/3x(s-2)) < 0.13　　です。

全てのxが1000とすると、
　log(1+1/3/1000)^270 = 0.129 < 0.13　なので
全てのyが1000より大きいならば
　log(1+1/3yt)…(1+1/3y(s-2)) < 0.13、
　Ay(s-2) < 0.83　　となります。

コラッツ値が1000より大きいときは、
　A(s-2) < 0.83　　が成り立つことがわかりました。

**righ1113** · 2014/12/15(月) 21:42:27.39

これじゃだめか…

**１３２人目の素数さん** · 2014/12/20(土) 16:51:43.61

>>12のスレにいたもんだが、割数列について今更発見があったので報告しとく

自然数a,bに対し、
[a,b]が割数列 ⇔ b≡2(-1)^a (mod 6)

単純な式だけど、５年前はこれに気付かなかった
さらに

自然数a,bに対し、
[a,b]が完全割数列 ⇔ (6a-4)+((-1)^a)(6-b)≡0 (mod 18)

自然数a,b,cに対し、
[a,b,c]が割数列 ⇔ (6b-4)+((-1)^b)(6-c)≡6(-1)^a (mod 18)

が見つかった。こうやって式で表せば何かわかるかもと思ったけど、今のところサッパリ

**righ1113** · 2014/12/22(月) 03:25:05.29

ありがとうございます。

**righ1113** · 2015/01/06(火) 23:59:12.52

ちょっと滞っています。

**righ1113** · 2015/01/26(月) 23:27:32.10

ぶれぶれですみませんが、また証明を戻して、>>99特定のパターンを列挙する方向でいきたいと思います。
ちょっと先になります。今brainf*ckやってるので……

**１３２人目の素数さん** · 2015/02/28(土) 11:38:28.03

test

**righ1113** · 2015/03/16(月) 03:00:44.03

まだ穴を埋められませんが、今は、
コラッツパターンと左端を伸ばすパターンのずれがなくなる事を言うのに、
双方の上位nビットの全パターンを調べる
という事を考えています。コンピュータを使おうと思っています。

**righ1113** · 2015/03/23(月) 21:14:44.93

予告とは違う物になりましたが、できたので書きます。

【言いたい事】
コラッツパターンと左端を伸ばすパターンのずれが有限値に収まる

新しいシミュレーションを2つ考えます。
【シミュレーションA】
1.nビットの初期値x0Aを用意する。
2.x0Aを下位へ1ビットシフトして（末尾は捨てる）、x0Aに加える。
3.最下位ビットに1加える。（下位からの繰り上がりが常に有る事を想定）
4.n+1ビットになっていたら、最下位ビットを捨ててnビットにする。
5.2~4を繰り返す。
得られる値をxsAとする。

【シミュレーションB】
1.nビットの初期値y0Bを用意する。
2.y0Bを下位へ1ビットシフトして（末尾は捨てる）、y0Bに加える。
（下位からの繰り上がりは常に無い）
3.n+1ビットになっていたら、最下位ビットを捨ててnビットにする。
4.2~3を繰り返す。
得られる値をysBとする。

**righ1113** · 2015/03/23(月) 21:27:59.02

xsA、ysB、コラッツパターン値xs、左端を伸ばすパターン値ys
の大小関係を考えます。

コラッツパターンは、下位からの繰り上がりが有ったり無かったりするので、
Upper_nbit xs < xsA
です。Upper_nbitは上位nビットを取るものです。

左端を伸ばすパターンは、下位からの繰り上がりが有ったり無かったりするので、
ysB < Upper_nbit ys
です。

Upper_nbit ys < Upper_nbit xsは自明なので、まとめると、
ysB < Upper_nbit ys < Upper_nbit xs < xsA
となります。

**righ1113** · 2015/03/23(月) 21:33:48.25

2つのシミュレーションA,Bを比べて、ずれが有限値に収まれば、
2つのシミュレーションA,Bにはさまれた
xs,ysのずれも有限値に収まる、と言えます。
（続く）

**righ1113** · 2015/03/23(月) 21:55:57.57

ysB ≦ Upper_nbit ys ≦ Upper_nbit xs ≦ xsA
でした。

**righ1113** · 2015/03/25(水) 20:49:24.82

2つのシミュレーションA,Bのずれが有限である事を言うのに、
プログラムを使います。Haskellでやります。
----------
module CollatzPatt where

type Bit = Int

plusDisplace :: [Bit] -> [Bit]
plusDisplace x = zipWith (+) x ((tail x) ++ [0])

movesUp :: [Bit] -> [Bit]
movesUp [x0] = case x0 of
0 -> [0]
1 -> [1]
2 -> [0,1]
3 -> [1,1]
movesUp (x0:x1:xs) = case x0 of
0 -> 0 : movesUp (x1:xs)
1 -> 1 : movesUp (x1:xs)
2 -> 0 : movesUp ((x1+1):xs)
3 -> 1 : movesUp ((x1+1):xs)

plusOne :: [Bit] -> [Bit]
plusOne (x:xs) = ((x+1):xs)

snd0or1 :: Int -> [Bit] -> Int
snd0or1 n x = if n == length x then 0 else 1

bitCutdown :: Int -> [Bit] -> [Bit]
bitCutdown n x = if n == length x then x else tail x

**righ1113** · 2015/03/25(水) 20:50:16.34

colPattA :: ([Bit],Int) -> ([Bit],Int)
colPattA (x,_) = let a = plusDisplace x
b = movesUp a
c = plusOne b
d = movesUp c
s = snd0or1 bitLen d
e = bitCutdown bitLen d
in (e,s)

colPattB :: ([Bit],Int) -> ([Bit],Int)
colPattB (x,_) = let a = plusDisplace x
b = movesUp a
s = snd0or1 bitLen b
c = bitCutdown bitLen b
in (c,s)

loopTp :: [([Bit],Int)] -> [([Bit],Int)]
loopTp x = loopTp' 2 x
where loopTp' n x =
if any (== fst (last x')) (init $ map fst x') then x'
else loopTp' (n+1) x
where x' = take n x

bitLen = 9
collatzPatternA :: [([Bit],Int)]
collatzPatternA = loopTp $ iterate colPattA ([1,1,1,1,1,1,1,1,1],0)
collatzPatternB :: [([Bit],Int)]
collatzPatternB = loopTp $ iterate colPattB ([0,0,0,0,0,0,0,0,1],0)
----------

**righ1113** · 2015/03/25(水) 20:51:32.29

n=9ビットで、欲しい結果が得られました。
結果です。
----------
*CollatzPatt> collatzPatternA
[([1,1,1,1,1,1,1,1,1],0),([1,1,1,1,1,1,1,0,1],1),([1,1,1,1,1,0,0,0,1],1),([1,1,1
,1,0,1,0,1,1],0),([1,1,0,0,0,0,1,0,1],1),([1,0,1,0,0,1,1,1,1],0),([0,0,1,1,0,1,1
,0,1],1),([1,0,0,0,1,0,0,0,1],1),([0,1,0,1,1,0,0,1,1],0),([0,0,1,0,1,1,0,0,1],1)
,([1,1,1,1,0,0,1,1,1],0),([1,1,0,1,1,0,1,0,1],1),([0,0,1,0,0,0,0,0,1],1),([1,1,1
,0,0,0,0,1,1],0),([1,0,1,0,0,1,0,0,1],1),([0,0,0,1,1,1,0,1,1],0),([0,1,0,1,0,0,1
,0,1],1),([0,0,0,0,1,1,1,1,1],0),([0,0,1,0,1,1,1,0,1],1),([1,1,1,0,1,0,0,0,1],1)
,([1,1,0,0,0,1,0,1,1],0),([0,1,0,1,1,1,0,0,1],1),([0,0,0,1,1,0,1,1,1],0),([0,1,0
,0,0,1,1,0,1],1),([0,1,0,1,0,0,0,0,1],1),([0,0,0,0,1,0,0,1,1],0),([0,0,1,1,0,1,0
,0,1],1),([1,1,0,0,0,0,1,1,1],0),([0,1,0,0,1,0,1,0,1],1),([0,0,1,1,1,1,1,1,1],0)
,([1,0,1,1,1,1,1,0,1],1),([0,1,1,1,1,0,0,0,1],1),([0,1,1,1,0,1,0,1,1],0),([1,1,0
,0,0,0,1,0,1],1)]

**righ1113** · 2015/03/25(水) 20:52:04.70

*CollatzPatt> collatzPatternB
[([0,0,0,0,0,0,0,0,1],0),([0,0,0,0,0,0,0,1,1],0),([0,0,0,0,0,1,0,0,1],1),([0,0,0
,0,1,1,0,1,1],0),([0,0,1,0,0,0,1,0,1],1),([0,1,1,0,0,1,1,1,1],0),([0,0,1,1,0,1,1
,0,1],1),([1,0,0,0,1,0,0,0,1],1),([1,0,0,1,1,0,0,1,1],0),([0,1,0,0,1,1,0,0,1],1)
,([1,1,0,1,0,0,1,1,1],0),([0,0,0,1,1,0,1,0,1],1),([0,1,0,0,0,0,0,0,1],1),([1,1,0
,0,0,0,0,1,1],0),([0,1,0,0,0,1,0,0,1],1),([1,1,0,0,1,1,0,1,1],0),([0,1,1,0,0,0,1
,0,1],1),([1,0,0,1,0,1,1,1,1],0),([0,1,1,1,0,1,1,0,1],1),([0,1,0,0,1,0,0,0,1],1)
,([1,1,0,1,1,0,0,1,1],0),([0,0,1,0,1,1,0,0,1],1),([0,1,1,1,0,0,1,1,1],0),([0,1,0
,1,1,0,1,0,1],1),([1,1,0,0,0,0,0,0,1],1),([0,0,1,0,0,0,0,1,1],0),([1,1,0,0,0,1,0
,0,1],1),([0,0,1,0,1,1,0,1,1],0),([1,1,1,0,0,0,1,0,1],1),([0,1,0,1,0,1,1,1,1],0)
,([1,1,1,1,0,1,1,0,1],1),([1,1,0,0,1,0,0,0,1],1),([0,0,1,1,1,0,0,1,1],0),([1,0,1
,0,1,1,0,0,1],1),([1,1,1,1,0,0,1,1,1],0),([1,1,0,1,1,0,1,0,1],1),([0,0,1,0,0,0,0
,0,1],1),([0,1,1,0,0,0,0,1,1],0),([0,0,1,0,0,1,0,0,1],1),([0,1,1,0,1,1,0,1,1],0)
,([0,0,0,1,0,0,1,0,1],1),([0,0,1,1,0,1,1,1,1],0),([1,0,0,0,1,1,1,0,1],1),([0,0,1
,0,1,0,0,0,1],1),([0,1,1,1,1,0,0,1,1],0),([0,1,1,0,1,1,0,0,1],1),([1,0,0,0,1,0,1
,1,1],0),([0,0,1,1,1,0,1,0,1],1),([1,0,1,0,0,0,0,0,1],1),([1,1,1,0,0,0,0,1,1],0)
,([1,0,1,0,0,1,0,0,1],1),([1,1,1,0,1,1,0,1,1],0),([1,0,0,1,0,0,1,0,1],1),([1,0,1
,1,0,1,1,1,1],0),([1,0,0,0,1,1,1,0,1],1)]
----------

**righ1113** · 2015/03/29(日) 18:42:21.03

collatzPatternAは、第33項が[1,1,0,0,0,0,1,0,1]となって、
第4項と一致します。その後は繰り返しになります。
collatzPatternBは、第54項が[1,0,0,0,1,1,1,0,1]となって、
第42項と一致します。その後は繰り返しになります。

collatzPatternAとBの第2要素を使って、2つのパターンのずれを比べます。
0ならば繰り上がり無しで、1ならば繰り上がり有りです。
#は、そこから繰り返しになっているという意味です。

*CollatzPatt> map snd collatzPatternA
[0,1,1,0,1,#0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1]

*CollatzPatt> map snd collatzPatternB
[0,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,
0,1,1,0,1,0,1,0,1,#1,0,1,0,1,1,0,1,0,1,0,1]

**righ1113** · 2015/03/29(日) 19:02:14.21

2つのパターンの第2要素を羅列します。繰り返しを並べていきます。
@はずれが1になっている所です。それ以降のはみ出た部分は、次の行にまわしています。
[0,1,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1]
[0,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1,

0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1]
0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,@1,0,1,0,1]★ここへ戻る

0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,@1,0,1]
0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,@1]

1]0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1]
1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,@1,0,1,0,1,0,1]

0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1]
0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,@1]

0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1]
1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,@1,1,0,1,0,1,0,1]

0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1]
1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,@1,0,1,0,1]

0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,@1,0,1]
1,0,1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,@1]

0,1]0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1]
1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,@1,0,1,0,1,0,1]

0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1]
1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,@1]

**righ1113** · 2015/03/29(日) 19:03:07.80

0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1]
1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,@1,1,0,1,0,1,0,1]

0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1]
1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,@1,0,1]

0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,@1,1,0,1]
0,1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,@1]

1,0,1]0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1]
1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,1,0,1,0,1]1,0,1,0,1,1,0,@1,0,1,0,1]★↑ 👀

**righ1113** · 2015/03/29(日) 19:08:28.94

2つのパターンのずれも、大きい繰り返しになる事が分かりました。
ずれは最大でも2なので、
ysB ≦ Upper_nbit ys ≦ Upper_nbit xs ≦ xsA　より、
コラッツパターンと左端を伸ばすパターンのずれが有限値に収まる
事が言えました。

**righ1113** · 2015/03/29(日) 19:55:39.51

>>228にミスがありました。
しばしお待ちください。

**righ1113** · 2015/03/30(月) 01:17:21.70

n=9ビットでは、ずれが無限大になってしまうので、
n=10にします。

*CollatzPatt> collatzPatternA
[([1,1,1,1,1,1,1,1,1,1],0),([1,1,1,1,1,1,1,1,0,1],1),([1,1,1,1,1,1,0,0,0,1],1),(
[1,1,1,1,1,0,1,0,1,1],0),([1,1,1,0,0,0,0,1,0,1],1),([1,1,0,1,0,0,1,1,1,1],0),([0
,0,0,1,1,0,1,1,0,1],1),([0,1,0,0,0,1,0,0,0,1],1),([0,0,1,0,1,1,0,0,1,1],0),([1,1
,1,0,0,1,1,0,0,1],1),([1,1,0,1,1,0,0,1,1,1],0),([0,0,1,0,1,1,0,1,0,1],1),([1,1,1
,0,0,0,0,0,0,1],1),([1,1,0,1,0,0,0,0,1,1],0),([0,0,0,1,0,0,1,0,0,1],1),([1,0,1,1
,0,1,1,0,1,1],0),([0,1,0,0,1,0,0,1,0,1],1),([0,0,1,1,1,0,1,1,1,1],0),([1,0,1,0,0
,1,1,1,0,1],1),([0,0,1,1,0,1,0,0,0,1],1),([1,1,0,0,0,0,1,0,1,1],0),([0,1,0,0,1,1
,1,0,0,1],1),([0,0,1,1,0,1,0,1,1,1],0),([1,0,0,0,0,0,1,1,0,1],1),([1,0,0,0,1,0,0
,0,0,1],1),([0,1,0,1,1,0,0,0,1,1],0),([0,0,1,0,1,0,1,0,0,1],1),([1,1,1,1,1,1,1,0
,1,1],0),([1,1,1,1,1,0,0,1,0,1],1),([1,1,1,1,0,1,1,1,1,1],0),([1,1,0,0,1,1,1,1,0
,1],1),([0,1,1,0,1,1,0,0,0,1],1),([0,1,0,0,1,0,1,0,1,1],0),([0,1,1,1,1,1,1,0,0,1
],1),([0,1,1,1,1,1,0,1,1,1],0),([1,1,1,1,0,0,1,1,0,1],1),([1,1,0,1,1,0,0,0,0,1],
1),([1,0,0,1,0,1,0,0,1,1],0),([1,1,1,1,1,0,1,0,0,1],1),([1,1,1,1,0,0,0,1,1,1],0)
,([1,1,0,1,0,1,0,1,0,1],1),([0,0,0,0,0,0,0,0,0,1],1),([1,0,0,0,0,0,0,0,1,1],0),(
[1,0,0,0,0,0,1,0,0,1],1),([0,1,0,0,0,1,1,0,1,1],0),([0,1,0,1,0,0,0,1,0,1],1),([0
,0,0,0,1,0,1,1,1,1],0),([0,0,1,1,1,0,1,1,0,1],1),([1,0,1,0,0,1,0,0,0,1],1),([0,0
,0,1,1,1,0,0,1,1],0),([0,1,0,1,0,1,1,0,0,1],1),([0,0,0,0,0,1,0,1,1,1],0),([0,0,0
,1,1,1,0,1,0,1],1),([0,1,0,1,0,0,0,0,0,1],1),([0,0,0,0,1,0,0,0,1,1],0),([0,0,1,1
,0,0,1,0,0,1],1),([1,1,0,0,1,1,1,0,1,1],0),([0,1,1,0,1,0,0,1,0,1],1),([0,1,0,0,0
,1,1,1,1,1],0),([0,1,0,1,0,1,1,1,0,1],1),([0,0,0,0,1,1,0,0,0,1],1),([1,0,0,1,0,0
,1,0,1,1],0),([1,1,1,0,1,1,1,0,0,1],1),([1,1,0,0,1,1,0,1,1,1],0),([0,1,1,0,0,0,1

**righ1113** · 2015/03/30(月) 01:18:02.58

,1,0,1],1),([1,0,1,0,1,0,0,0,0,1],1),([0,0,0,0,0,1,0,0,1,1],0),([0,0,0,1,1,0,1,0
,0,1],1),([1,0,1,0,0,0,0,1,1,1],0),([0,0,1,0,0,1,0,1,0,1],1),([1,1,1,0,1,1,1,1,1
,1],0),([1,0,0,1,1,1,1,1,0,1],1),([1,1,0,1,1,1,0,0,0,1],1),([1,0,0,1,1,0,1,0,1,1
],0),([1,1,0,0,0,0,0,1,0,1],1),([1,0,1,0,0,0,1,1,1,1],0),([0,0,1,0,1,0,1,1,0,1],
1),([1,1,1,1,1,0,0,0,0,1],1),([1,1,1,1,0,1,0,0,1,1],0),([1,1,0,0,0,1,1,0,0,1],1)
,([1,0,1,0,1,0,0,1,1,1],0),([0,0,0,0,1,1,0,1,0,1],1),([0,0,1,0,0,0,0,0,0,1],1),(
[1,1,1,0,0,0,0,0,1,1],0),([1,0,1,0,0,0,1,0,0,1],1),([0,0,0,1,0,1,1,0,1,1],0),([0
,1,1,1,0,0,0,1,0,1],1),([0,1,1,0,1,0,1,1,1,1],0),([1,0,0,0,0,1,1,1,0,1],1),([1,0
,0,1,0,1,0,0,0,1],1),([0,1,1,1,1,1,0,0,1,1],0),([1,1,1,1,0,1,1,0,0,1],1),([1,1,1
,0,0,1,0,1,1,1],0),([1,0,1,1,1,1,0,1,0,1],1),([0,1,1,1,0,0,0,0,0,1],1),([0,1,1,0
,1,0,0,0,1,1],0),([1,0,0,0,1,0,1,0,0,1],1),([0,1,0,1,1,1,1,0,1,1],0),([0,0,1,1,1
,0,0,1,0,1],1),([1,1,0,1,0,1,1,1,1,1],0),([0,0,0,0,1,1,1,1,0,1],1),([0,0,1,0,1,1
,0,0,0,1],1),([1,1,1,1,0,0,1,0,1,1],0),([1,1,0,1,1,1,1,0,0,1],1),([1,0,0,1,1,1,0
,1,1,1],0),([1,1,0,1,0,0,1,1,0,1],1),([0,0,0,1,1,0,0,0,0,1],1),([1,0,1,0,0,1,0,0
,1,1],0),([0,0,1,1,1,0,1,0,0,1],1),([1,1,0,1,0,0,0,1,1,1],0),([0,0,0,1,0,1,0,1,0
,1],1),([1,0,1,1,1,1,1,1,1,1],0),([0,1,1,1,1,1,1,1,0,1],1),([1,1,1,1,1,1,0,0,0,1
],1)]

**righ1113** · 2015/03/30(月) 01:19:23.47

*CollatzPatt> collatzPatternB
[([0,0,0,0,0,0,0,0,0,1],0),([0,0,0,0,0,0,0,0,1,1],0),([0,0,0,0,0,0,1,0,0,1],1),(
[0,0,0,0,0,1,1,0,1,1],0),([0,0,0,1,0,0,0,1,0,1],1),([0,0,1,1,0,0,1,1,1,1],0),([1
,0,0,1,1,0,1,1,0,1],1),([0,1,0,0,0,1,0,0,0,1],1),([1,1,0,0,1,1,0,0,1,1],0),([0,1
,1,0,0,1,1,0,0,1],1),([1,0,0,1,1,0,0,1,1,1],0),([0,1,0,0,1,1,0,1,0,1],1),([1,0,1
,0,0,0,0,0,0,1],1),([1,1,1,0,0,0,0,0,1,1],0),([1,0,1,0,0,0,1,0,0,1],1),([1,1,1,0
,0,1,1,0,1,1],0),([1,0,1,1,0,0,0,1,0,1],1),([1,1,0,0,1,0,1,1,1,1],0),([0,1,1,1,1
,0,1,1,0,1],1),([0,1,1,0,0,1,0,0,0,1],1),([1,0,0,1,1,1,0,0,1,1],0),([0,1,0,1,0,1
,1,0,0,1],1),([1,1,1,1,1,0,0,1,1,1],0),([1,1,1,0,1,1,0,1,0,1],1),([1,0,0,1,0,0,0
,0,0,1],1),([1,0,1,1,0,0,0,0,1,1],0),([1,0,0,1,0,0,1,0,0,1],1),([1,0,1,1,0,1,1,0
,1,1],0),([1,0,0,0,1,0,0,1,0,1],1),([1,0,0,1,1,0,1,1,1,1],0),([0,1,0,0,0,1,1,1,0
,1],1),([1,0,0,1,0,1,0,0,0,1],1),([1,0,1,1,1,1,0,0,1,1],0),([1,0,1,1,0,1,1,0,0,1
],1),([1,1,0,0,0,1,0,1,1,1],0),([0,1,0,1,1,1,0,1,0,1],1),([1,1,0,1,0,0,0,0,0,1],
1),([0,0,0,0,1,0,0,0,1,1],0),([0,0,1,1,0,0,1,0,0,1],1),([0,1,0,0,1,1,1,0,1,1],0)
,([1,0,1,0,1,0,0,1,0,1],1),([1,1,1,1,1,0,1,1,1,1],0),([1,1,1,0,0,1,1,1,0,1],1),(
[1,0,1,1,0,1,0,0,0,1],1),([1,1,0,0,0,0,1,0,1,1],0),([0,1,0,0,1,1,1,0,0,1],1),([1
,1,0,1,0,1,0,1,1,1],0),([0,0,0,0,0,0,1,1,0,1],1),([0,0,0,0,1,0,0,0,0,1],1),([0,0
,0,1,1,0,0,0,1,1],0),([0,1,0,0,1,0,1,0,0,1],1),([1,1,0,1,1,1,1,0,1,1],0),([0,0,1
,1,1,0,0,1,0,1],1),([0,1,0,1,0,1,1,1,1,1],0),([1,1,1,1,0,1,1,1,0,1],1),([1,1,0,0

**righ1113** · 2015/03/30(月) 01:28:09.67

,1,1,0,0,0,1],1),([0,0,1,1,0,0,1,0,1,1],0),([1,0,0,1,1,1,1,0,0,1],1),([1,0,1,0,1
,1,0,1,1,1],0),([1,1,1,0,0,0,1,1,0,1],1),([1,0,1,0,1,0,0,0,0,1],1),([1,1,1,1,1,0
,0,0,1,1],0),([1,1,1,0,1,0,1,0,0,1],1),([0,1,0,0,0,0,0,1,1,1],0),([1,0,0,0,0,1,0
,1,0,1],1),([1,0,0,0,1,1,1,1,1,1],0),([0,0,1,0,1,1,1,1,0,1],1),([1,1,1,0,1,1,0,0
,0,1],1),([0,1,0,0,1,0,1,0,1,1],0),([1,0,1,1,1,1,1,0,0,1],1),([1,1,0,1,1,1,0,1,1
,1],0),([0,0,1,1,0,0,1,1,0,1],1),([1,0,0,1,1,0,0,0,0,1],1),([1,0,1,0,0,1,0,0,1,1
],0),([1,1,0,1,1,0,1,0,0,1],1),([0,0,0,1,0,0,0,1,1,1],0),([0,1,1,0,0,1,0,1,0,1],
1),([1,0,0,1,1,1,1,1,1,1],0),([0,1,0,1,1,1,1,1,0,1],1),([1,1,0,1,1,1,0,0,0,1],1)
,([0,0,0,1,1,0,1,0,1,1],0),([0,1,0,0,0,0,0,1,0,1],1),([1,1,0,0,0,0,1,1,1,1],0),(
[0,1,0,0,1,0,1,1,0,1],1),([1,0,1,1,1,0,0,0,0,1],1),([1,1,0,1,0,1,0,0,1,1],0),([0
,0,0,0,0,1,1,0,0,1],1),([0,0,0,0,1,0,0,1,1,1],0),([0,0,1,1,0,1,0,1,0,1],1),([1,0
,0,0,0,0,0,0,0,1],1),([1,0,0,0,0,0,0,0,1,1],0),([0,0,0,0,0,0,1,0,0,1],1)]

**righ1113** · 2015/03/30(月) 01:32:28.57

collatzPatternAは、第115項が[1,1,1,1,1,1,0,0,0,1]となって、
第3項と一致します。その後は繰り返しになります。
collatzPatternBは、第93項が[0,0,0,0,0,0,1,0,0,1]となって、
第3項と一致します。その後は繰り返しになります。

collatzPatternAとBの第2要素を使って、2つのパターンのずれを比べます。
0ならば繰り上がり無しで、1ならば繰り上がり有りです。
#は、そこから繰り返しになっているという意味です。

*CollatzPatt> map snd collatzPatternA
+[0,1,1,#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0
,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1
,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1]
*CollatzPatt> map snd collatzPatternB
[0,0,1,#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0
+,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1
,0,1,0,1,1,0,1,0,1,1,0,1]

**righ1113** · 2015/03/30(月) 01:33:51.63

2つのパターンの第2要素を羅列します。繰り返しを並べていきます。
@はずれが1になっている所です。それ以降のはみ出た部分は、次の行にまわしています。
[0,1,1,#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,@1,0
[0,0,1,#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,@1,0

,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,@1
,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,@1

,0,1,1,0,1,0,1,0,1,1,0,1, 0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,@1]★
,0,1,0,1,1,0,1,0,1,1,0,1]#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,@1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0

#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,@1,0
0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,@1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1

,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,@1,0,1,1,0,1,0,1,1,0,1
,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,1,0,@1]

,0,1,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,@1,1,0,1,0,1,0,1,1]
#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,@1,0

,1,0,1,0,1,0,1,1]#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,@1,1,0,1,0
,0,1,0,1,1,0,1,0 ,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,@1

,1,0,@1,0
,0,1,0,@1,1,0,1,0,1,1,0,1]

,1,1,0,1,0,1,0,1, 1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,@1,0
,1,0,1,0,1,1,0,1]#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,@1,1,0,1,0

**righ1113** · 2015/03/30(月) 01:34:23.75

,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,@1]
,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,@1,0,1,1,0,1,0,1,0,1,1

#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,@1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0
,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,1,0,@1]

,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,@1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1
#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,@1,0

,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,@1,0,1,0,1,1,0,1,0,1,0,1,1]
,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,@1

,0,1,0,1,1,0,1,0,1,0,1,@1]
,0,1,0,1,1,0,1,0,1,1,0,@1]

#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,@1,0
#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,@1,0

,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,@1
,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,@1

,0,1,1,0,1,0,1,0,1,1,0,1, 0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,@1]★にLoopする
,0,1,0,1,1,0,1,0,1,1,0,1]#0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,1,0,1,0,1,@1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,0

**righ1113** · 2015/03/30(月) 01:35:08.16

2つのパターンのずれも、大きい繰り返しになる事が分かりました。
ずれは最大でも2なので、
ysB ≦ Upper_nbit ys ≦ Upper_nbit xs ≦ xsA　より、
コラッツパターンと左端を伸ばすパターンのずれが有限値に収まる
事が言えました。

**righ1113** · 2015/04/13(月) 01:58:32.71

>>220にミスがあったので直します。

**righ1113** · 2015/04/18(土) 15:42:26.62

xsA、ysB、コラッツパターン値Xs、左端を伸ばすパターン値Ys
の大小関係を考えます。
Xs = X0*(3/2)^s*(1+1/3x0)...(1+1/3xs-1)
Ys = X0*(3/2)^s
です。

コラッツパターンは、下位からの繰り上がりが有ったり無かったりするので、
Xs < xsA * 2^pxs + (2^pxs-1)(下位を1埋め)
です。
2^pxsはコラッツパターンと桁をそろえるものです。
px0 = [X0と右端を合わせる]
pxs = | pxs-1 +1 [右端の繰り上がり有り]
　　　| pxs-1 [右端の繰り上がり無し]

左端を伸ばすパターンは、下位からの繰り上がりが有ったり無かったりするので、
ysB * 2^pys < Ys
です。

Ys < Xsは自明なので、まとめると、
ysB * 2^pys < Ys < Xs < xsA * 2^pxs + (2^pxs-1)
となります。

2つのシミュレーションA,Bを比べて、ずれが有限値に収まれば、
2つのシミュレーションA,Bにはさまれた
Xs,Ysのずれも有限値に収まる、と言えます。

**righ1113** · 2015/05/05(火) 11:06:41.39

今TeXでがんばってます。

**righ1113** · 2015/05/17(日) 16:54:03.93

TeX執筆中……

**righ1113** ◆OPKWA8uhcY · 2015/05/31(日) 13:11:49.25

TeX執筆中……

**righ1113** ◆OPKWA8uhcY · 2015/06/13(土) 15:17:58.73

TeX執筆中……

**righ1113** ◆OPKWA8uhcY · 2015/06/27(土) 18:14:43.44

TeX執筆中……

**righ1113** ◆OPKWA8uhcY · 2015/07/05(日) 14:17:04.32

TeX執筆中……

**righ1113** ◆OPKWA8uhcY · 2015/07/18(土) 17:43:39.93

TeX執筆中……

**righ1113** ◆OPKWA8uhcY · 2015/08/01(土) 18:09:10.03

はや4ヶ月か……

**１３２人目の素数さん** · 2015/08/22(土) 10:38:32.65

素朴な疑問だけど、3ｘ+1したら綺麗に1→4→2→1に収束するのに
3ｘ-1したら少なくとも3つぐらいのループに分かれてしまう

この「+1」の意味って何なんだろうな

**righ1113** ◆OPKWA8uhcY · 2015/08/29(土) 14:58:45.22

奇数を偶数にするためとか
そんなことを言っているんじゃないですよね(>_<)

**１３２人目の素数さん** · 2015/08/30(日) 04:32:48.31

>>251
もちろん、偶数にするための+1なんだろうけど

「3ｘ+1」したら綺麗に1個のループ（1→4→2→1）に収束
「3ｘ-1」したら複数のループに収束（収束と言っていいのか？）

という風に性質が全く異なる
高々「+1」か「-1」の違いなのにね

コラッツ問題の証明には、この辺りの理由の解明が必要だと思う

**成清 愼** · 2015/09/01(火) 12:19:34.67

私なりの考えを書いてみました。数学は素人なので数学の表現は最低クラス
だと思いますがこの板の諸兄におかれましては何卒よろしくご査収の上
ご批評賜れば幸いです。

http://koubeichizoku.doujin.so/collatz/collatz.htm

**righ1113** ◆OPKWA8uhcY · 2015/09/02(水) 20:29:33.34

むずかしー

**成清 愼** · 2015/09/02(水) 22:06:42.96

>>253には致命的欠陥があるので修正中です

**成清 愼** · 2015/09/02(水) 22:18:09.71

>>254
70年間解かれなかった問題に解答しようというんだからかなり難解なものにならざるを得ないけど、
ワイルズがフェルマーの定理に与えた解答にくらべれば100分の1くらいの難易度だと思う

**成清 愼** · 2015/09/11(金) 03:47:51.53

>>255
修正おわりました。ご査収、ご批評の程よろしくお願い申し上げます。 m(_ _)m

**成清 愼** · 2015/09/11(金) 06:35:54.90

>>250
例えば　（7×3+1）÷2＝11、（29×3+1）÷2÷2÷2＝11
で、7×4+1=29、つまりある奇数を4倍して1を足した奇数は
このる奇数と同じ値へと変化します。
奇数ｘを初項とする漸化式　an+1=an×4+1であらわされる数列の一般項が
たまたま、(y×2^n-1)÷3だからです。

**成清 愼** · 2015/09/11(金) 06:38:51.50

(y×2^2n-1)÷3でしたすいません。

**成清 愼** · 2015/09/11(金) 06:43:51.33

コラッツ予想はこの数列の一般項を求める関数の反対写像にあたっているのです。

**１３２人目の素数さん** · 2015/09/11(金) 12:19:34.06

▲マインドコントロールの手法▲

・沢山の人が偏った意見を一貫して支持する
　偏った意見でも、集団の中でその意見が信じられていれば、自分の考え方は間違っているのか、等と思わせる手法

・不利な質問をさせなくしたり、不利な質問には答えない、スルーする
　誰にも質問や反論をさせないことにより、誰もが皆、疑いなど無いんだと信じ込ませる手法

偏った思想や考え方に染まっていたり、常識が通じない人間は、頭が悪いフリをしているカルト工作員の可能性が高い

靖国参拝、皇族、国旗国歌、神社神道を嫌うカルト

10人に一人はカルトか外国人

「ガスライティング」で検索を！

**成清 愼** · 2015/09/11(金) 22:34:23.76

再修正いたしました。「ウソ八百を信じ込ませようとするな」でも何でも結構ですので
何卒よろしくご査収の上ご高評賜れば幸いです。

http://koubeichizoku.doujin.so/collatz/collatz.htm

**１３２人目の素数さん** · 2015/09/12(土) 09:14:53.79

>>262
命題1の証明がおかしい。最初の2行で、J(g(h(a,q),c))が空集合でないことを理由にして
「 Cola(g(h(a,q),c)) は未だ実行されていない」としているが、そうとは限らない。
以下では、(3x＋1)問題ではなく(3x－1)問題を扱う。それでも問題点は本質的に
同じことであるから、ご了承ねがいたい。

まず、初期状態のJ(v)のうち、次のものだけを列挙する。

J(17) = { 17 }, J(25) = { 25 }. J(37) = { 37 }, J(55) = { 55 }, J(41) = { 41 }, J(61) = { 61 }, J(91) = { 91 }

以下、(3x－1)問題において、順次 Cola(17), Cola(25), Cola(37), Cola(55), Cola(41), Cola(61), Cola(91) までを1回ずつ実行すると、

J(17) = { 17 }, J(25) = { 25 }. J(37) = { 37 }, J(55) = { 55 }, J(41) = { 41 }, J(61) = { 61 }, J(91) = { 91 }
↓Cola(17)
J(17) = { }, J(25) = { 17, 25 }. J(37) = { 37 }, J(55) = { 55 }, J(41) = { 41 }, J(61) = { 61 }, J(91) = { 91 }
↓Cola(25)
J(17) = { }, J(25) = { }. J(37) = { 17, 25, 37 }, J(55) = { 55 }, J(41) = { 41 }, J(61) = { 61 }, J(91) = { 91 }
↓Cola(37)
J(17) = { }, J(25) = { }. J(37) = { }, J(55) = { 17, 25, 37, 55 }, J(41) = { 41 }, J(61) = { 61 }, J(91) = { 91 }
↓Cola(55)
J(17) = { }, J(25) = { }. J(37) = { }, J(55) = { }, J(41) = { 17, 25, 37, 55, 41 }, J(61) = { 61 }, J(91) = { 91 }
↓Cola(41)
J(17) = { }, J(25) = { }. J(37) = { }, J(55) = { }, J(41) = { }, J(61) = { 17, 25, 37, 55, 41, 61 }, J(91) = { 91 }
↓Cola(61)
J(17) = { }, J(25) = { }. J(37) = { }, J(55) = { }, J(41) = { }, J(61) = { }, J(91) = { 17, 25, 37, 55, 41, 61, 91 }
↓Cola(91)
J(17) = { 17, 25, 37, 55, 41, 61, 91 }, J(25) = { }. J(37) = { }, J(55) = { }, J(41) = { }, J(61) = { }, J(91) = { }

となる。今の段階で、17∈J(17) であるから J(17)は空集合ではない。しかし、Cola(17) は既に1回だけ実行済みである。
従って、Cola が未だ実行されてないことを前提とした、命題1の証明は全滅だと思われる。

(続く)

**１３２人目の素数さん** · 2015/09/12(土) 09:18:47.39

(続き)
もちろんこれは(3x－1)問題における現象であるから、もともとのコラッツの問題とは無関係のように見えるかもしれない。
しかし、そんなことは無い。もともとのコラッツの問題でも、

・任意の「ループする数字の列 v1 >> v2 >> v3 >> …… >> vn >> v1 >> v2 >> …… 」

に対して、全く同じ現象が起きる。すなわち、初期状態のJ(v)のうち、

J(v1) = { v1 }, J(v2) = { v2 }, J(v3) = { v3 }, ……, J(vn) = { vn }

だけを列挙する。この状態で、もともとのコラッツの問題において、順次 Cola(v1), Cola(v2), ……, Cola(vn) までを
1回ずつ実行すれば、

J(v1) = { v1, v2, ……, vn }, J(v2) = { }, J(v3) = { }, ……, J(vn) = { }

となり、全く同じ現象に遭遇する。つまり、今の段階で v1∈J(v1) であるが、しかし Cola(v1) は既に1回だけ実行済みなのである。
従って、もともとのコラッツの問題においても、Cola が未だ実行されてないことを前提とした命題1の証明は全滅だと思われる。

また、このことからも分かるように、もし実際にループがあるなら、ループする数字の集まり v1, v2, ……, vn は実際に「引越し」を繰り返すだけであり、
J(v) に関する手法は全く意味を成さない。Cola(v) を作用させる順番を工夫してみるとか、そういう話にすらならない。もし実際にループがあるなら、
Cola に応じて実際に引越しが行われるだけであり、そこに矛盾が生じることは原理的にありえないのである。
この感覚が腑に落ちないときは、(3x＋1)問題のみならず、一般の(ax＋b)問題ではどうなるかをイメージするとよい。
あなたが使っている手法が「 3x＋1 」に依存していない場面は、そっくりそのまま一般の(ax＋b)問題でも適用可能になるのである。
しかし、一般の(ax＋b)問題でおかしな現象が起きるなら、あなたが使っているその手法は、自動的に「どこかが間違っている」ことになる。
そこから逆算して、もともとの(3x＋1)問題に置き直してみれば、具体的にどこが間違っていたのかがハッキリする。

**１３２人目の素数さん** · 2015/09/12(土) 09:22:59.38

おそらく、この手法では、本質的にコラッツの問題は解けない。
ループする数字の列 v1 >> v2 >> v3 >> …… >> vn >> v1 >> v2 >> …… が実際にあったら、
もはや J(v) に関する手法は意味を成さず、Cola に応じて実際に引越しが行われるだけである。
実際に、(3x－1)問題のケースではそうなっている(>>263)。

では、どうすればいいのか。v1, v2, …, vn が具体的にどのような形状になっているかを詳しく解析するしかないだろう。
そして、(3x＋1)問題においては、ループする数字の列が 1 >> 1 >> 1 >> …… しかないことを証明すればよいのだ。
しかし、あなたもお気づきのとおり、これではスタートラインに逆戻りである。(だからこそコラッツの問題は未解決問題なのだ)

**成清 愼** · 2015/09/12(土) 12:02:30.75

>>263
貴重なご意見を頂戴いたしまして心より感謝いたします。
（3X-1)問題はほんの齧った程度なので、疎いので申し訳ないですが、
Cola（v）の定義の中で、　J(V）:＝{}というJ(V)を空集合として再定義する部分があります。
確かに91→17なので、17∈J(19）だからこの場合J（19）:＝J（19）∩J（19）となるのですが
J（17）={}は変わりません。しかしながらこれは命題1と表裏の関係にあるのでじっくり再考
してみます。有難うございます。

**成清 愼** · 2015/09/12(土) 12:06:38.38

貴重なご意見を頂戴いたしまして心より感謝いたします。
（3X-1)問題はほんの齧った程度なので、疎いので申し訳ないですが、
Cola（v）の定義の中で、　J(V）:＝{}というJ(V)を空集合として再定義する部分があります。
確かに91→17なので、17∈J(91）だからこの場合J（91）:＝J（91）∩J（91）となるのですが
J（17）={}は変わりません。しかしながらこれは命題1と表裏の関係にあるのでじっくり再考
してみます。有難うございます。
【書き間違いの訂正ですみません】

**成清 愼** · 2015/09/12(土) 12:22:23.35

確かにJ(v)≠{}だからCola(v)が実行されていないと言うのは話が逆ですね.
Cola(v)は各カテゴリーの中で小さい方から順番に実行されているのだから
いままさに実行しようとしている時はまだ≠｛｝だとかなんとか言う風に
もっていかないとダメですね。

**成清 愼** · 2015/09/12(土) 12:28:40.07

>>267
まだ違ってました。J（91）:＝J（91）∪　J（91）でした。度々でお詫び
いたします。

**１３２人目の素数さん** · 2015/09/12(土) 12:31:08.35

>>267
これは失敬した。移動先の J(v'') は v'∈J(v'') を満たしていなければならないことを失念していた。
となれば、命題1の証明は特に問題ないのかもしれない。申し訳ない。

>>268
たいへん申し訳ない。そこはもはや、大した問題ではないかもしれない(単なる書き方の順序の問題に過ぎないかもしれない)。
そのかわりに、今度は別の問題が発生している。まず、>>263の(3x－1)問題においては、

J(17) = { }, J(25) = { }. J(37) = { }, J(55) = { }, J(41) = { }, J(61) = { }, J(91) = { 17, 25, 37, 55, 41, 61, 91 }
↓Cola(91)
J(17) = { }, J(25) = { }. J(37) = { }, J(55) = { }, J(41) = { }, J(61) = { }, J(91) = { 17, 25, 37, 55, 41, 61, 91 }

となる。すなわち、J(91) に Cola(91) を実行しても何の変化も起こらないことになる(あなたも指摘されているように)。
同じく、もともとのコラッツの問題においては、>>264の設定のもとで

J(v1) = { }, J(v2) = { }, J(v3) = { }, ……, J(vn) = { v1, v2, ……, vn }
↓Cola(vn)
J(v1) = { }, J(v2) = { }, J(v3) = { }, ……, J(vn) = { v1, v2, ……, vn }

となる。すなわち、J(vn) に Cola(vn) を実行しても何の変化も起こらないことになる。これはつまり、

「 Cola(v) を実行しても、必ずしも J(v) は空集合にはならず、何の変化も起きない可能性がある」…… (1)

ということを意味する。一方で、あなたの議論では、

「 Cola(v) を実行して J(v) を空集合にしていけば、最後に残る空でない集合は J(1) のみである(よってコラッツ予想は正しい) 」

という方針で証明しようとしているように見える。ところが、上記の(1)のように、Cola(v)を実行しても
空にならず、全く変化しない J(v) が存在してしまうのなら、この方針は使えないことになる。
というか、(1)が起こるような J(v) に対して、J(v) の中身はまさに「ループする数字の列」になっているはずである。
となれば、J(v) の手法はループに関してやはり無力ということになってしまう。

**成清 愼** · 2015/09/12(土) 13:05:31.66

おっしゃる通りこの問題は恐ろしい問題でニワトリと卵のような、禅問答
みたいなことになってしまうことは十分承知しております。私の論もその
95%い以上は問題の核心である「ループが存在しない」ことの証明に向かっています
ただ、前述のように恐ろしい難問なのでどこかに穴があるだろうとは思っています。
よいご指摘を感謝いたします。しばらく沈思黙考してみます。

**成清 愼** · 2015/09/12(土) 13:31:51.26

一番悩ましいのは重複元という本来の集合論には存在しない概念を
ループがないことの証拠として持ち込んでいることです。
ただ、例えば集合Xの中に元17が1個あるとか2個あるとかいう概念が
あってもそれほどおかしなことではないと思っている自分の頭が
一番おかしいのかも知れません

**成清 愼** · 2015/09/12(土) 13:44:10.30

(3X+1)と(3X-1)の間に本質的違いはないとおっしゃる意味は或る程度理解しています。
ただ私の論が3X+1に特化しているというのもまた事実で、それは
a(n+1)=4a(n)+1という漸化式であらわされる数列をG(X）と言う形で持ち込んで
いることです。この数列の一般項を表す式は（3X+1）÷2^ｎと等価だからです。