巨大数探索スレッド7

巨大数研究室
http://www.geocities.co.jp/Technopolis/9946/

前スレ、過去スレ、避難所はこのページからどうぞ。

「前の数＋1」
「1/x　x→0」
「∞」
「９を延々と書き続けるプログラム」
「本日からこのスレでは、いっさいの数学的ではない話を禁止する。
私以外で検証する能力を持っている人間はいないようなので、
数学的に明確に証明できた場合以外は反論しないように。
特に今日のような低俗な煽りには徹底して放置で対応すること。」

という類の投稿は放置推奨。

ありがとうございます。
巨大数研究室からのリンク張り換えました。

いきなり無限の話ですが、「数の本」を片手に少々。
(現在、無限絡みの巨大数生成プロセスの議論が込み入ってるのです)

・ωって何？
「0,1,2,…　したがって、ω本の電柱がある」(抜粋)
というイメージだそうで、
「全ての有限の数よりも大きい"最初"の数」＝ω　とのことです。

・ωとかが絡んだ演算はどうなの？
ぶっちゃけ、定義があって大丈夫なようになってるみたいです。

・ε_0ってどんな？
とにかくωより十分でかいみたいです。タワーを使うと
ω↑↑ωという記述ができますが、これをε_0　と呼んでるみたいです。
こいつは　ω^ε＝ε　を満たす最初の数、とのことです。

そんで、もっと上もその上も、作れるみたいです。
とりあえず上の2種だけ噛み砕いてみました。

巨大数とは逆に小さい数の話だけど冪集合の濃度がN_0になるような自然数の部分集合って
つくれるのかな？今日一日カントールとか考えてたけど思いつかなかった

アレフ_0なら無理

アレフゼロが最小だというのは証明されていた気がする。どんな証明だったっけ？

選択公理を使用

無限集合は可算無限集合を部分集合として持つからアレフゼロ以上になるわけか

このスレは新しい巨大基数の公理でも見つけるスレなのかね

じゃなく高速に有限巨大数を作る方法を考えるスレかな？そのために順序数を利用しようという流れかと。

ビジービーバーはどうなった？

ωとか使えばビジービーバーを抜ける可能性があるわけ？
それとも無理なわけ？

>>12
両方巨大数を生み出せるという点では共通しているがその他の性質
が違いすぎるので比べるのは至難の技だと思う

ωを使った巨大数は、計算可能なの？

計算可能ならばBBの方が大きいだろうし、
計算不可能ならば…計算不可能なもの同士の大小を
比べるのは、至難だろうね。

>>14
前スレを参照すればわかるかもしれませんが
ω式の巨大数(関数)は超限帰納的なので計算可能だと思います。
ただ計算可能だからBB関数のほうが大きいかどうかは
よくわからないところです。

ＢＢはあらゆる計算可能な関数より大きいことになっている。

証明があるってことか？

ある関数fがｎ状態のチューリングマシンで計算可能で、入力がmなら
f(m)はBB(n+log(m))を超えられないようなキガス。
厳密なことはおれにはわからんが。

f(m)を計算するにはテープにmが書かれた状態で
fを計算するチューリングマシンを走らせればよい。
テープにmを書くチューリングマシンはlog(m)状態で
実現できるので、f(m)の値を得るには入力を生成する部分と
ｆを計算をする部分でn+log(m)状態あればよい。
BB(n+log(m))はn+log(m)状態で一番大きい数を出力するので
f(m)はBB(n+log(m))を超えられない。

と思ったけどBBの定義はテープに1を何個かけるかだっけ？
とすると2^f(m)とBB(n+log(m))を比べないといけない？
すまん。よくわからなくなってきた。

とおもったけど２のべき乗を計算する処理も入れてやれば良いのか？
２のべき乗を計算するチューリングマシンの状態をpとすれば
f(m)はBB(n+p+log(m))を超えられない。
スレ汚しスマソ。

BBの逆概念風なものに、コルモゴロフ複雑性ってのがあるんやね。
ウィキペに載ってた。

「計算可能」っていうのは単に「計算出来そう」という意味じゃなくて
厳密な定義がある概念ですよ。

オートマトンには状態数があるけどチューリングマシンの状態数って？
テープに状態を記録できるから状態数は∞のはずじゃ？

>>24
ここで言う「状態」はマシンの内部状態のことでせう

オートマトンには状態遷移表みたいなのが内蔵されるんよー。

まちがえた、チューリングマシンだった。

TMの状態数は計算可能性には関係ないんじゃなかったっけ？

1状態でも停止できないものが作れるからな。

状態数と計算可能性に関係がないのなら上限値にBB(n+log(m))のようにnが含まれるのは変な気がする

計算可能性と上限値に関連はないと思うけど。

状態数が多いほど計算できる関数は増える。

チューリングマシンを使わずに計算不能な関数は定義できるか？

出来る。再帰的でない函数のことなんだから。

というかチューリングマシン勉強したら習うだろ。

結局現時点で一番大きな数はなんなの？

範囲を有限にしないとこのスレの意味無いじゃん。

数自体は自然数しか扱っていないよ

なんつーかＢＢがある限り計算可能な関数の議論は白けてしまうっつーか。
厄介だな。

>>18-21の理屈で行くとfが単調増加関数だとするとテープに
ｍ以上の入力を書くのにはBB＾-1(m)状態あればいいから
f(m)はBB(n+p+BB^-1(m))を越えられないって事だな。
nもpも定数だしBB^-1(m)もほとんど定数みたいなもんだから
計算可能な関数はBBからみればまさに止まって見えるつーことだな。

ヒルベルト論理体系を超えた関数を作ろうぜ

>>40
kwsk

ｋｗｓｋというか意味がわからん

>>40がなんか面白そうなアイディアを持ってそうなのでkwsk聞きたかったのだが。

チューリングマシンで計算可能な関数はλ計算でも計算可能。逆も真
λ計算ではヒルベルト論理体系で構築できる全ての関数を計算可能
（まあ別にヒルベルトじゃなくてもいいけど）
だからBBを超えるにはλ計算の構築が不可能な論理体系に基づく関数が必要

とまで書いて気付いたけど不動点定理とか非停止問題があったな・・・

>>39の要領でフィッシュ数がＢＢのいくつ以下とか出せそうな気がする。
俺には無理だが。

ωって結局なによ？有限？無限？

sage忘れスマソ

チューリングマシンはバンダイで売っていますか？

量子コンピュータができたら高速で任意の
n 番目の素数を検索できたりするのかな？

そばで机を指でたたくと値が変わる

Gをグラハム数としてBB(G)↑↑BB(G)とBB(G+1)ってどっちが大きいと思う？
俺はBB(G+1)の方が大きいんじゃないかと思ってるんだが。
もちろんこんなもん比べようも無いがみんなの意見聞かせて。

>>51
漏れもBB(G)↑↑BB(G)＜BB(G+1)説に同意
そのレベルになるともう1増えるだけで全然違うだろうからな

BBって滑らかなのかぁ。などと言ってみるテスト。

talk:>>53 滑らかの定義から分かるように、必ず滑らかでない。

talk:>>53 それとも、滑らかである関数に延長できるのか？

kingこのスレみてたのか。
階乗なんかは滑らかな関数に延長できるんだっけ？

ガンマ関数のことかー。
まぁBBに関しては無理だろう。
BB(X)とBB(X+1)に計算可能な関係が存在しないんだから。

x<yならばBB(x+1)-BB(x)<BB(y+1)-BB(y)といえるか？

>>58
BB(x+1)<BB(y+1)-BB(y)+BB(x)
ということなので
まあ成り立つ

BB(2)-BB(1) = 3
BB(3)-BB(2) = 2

(･д･)

w

>>60
引数が小さなときだけの特殊な場合なのか、
もっと大きいときでも逆転が起こるのか興味あるな。
逆転が起こるとしたらどんな理由だろ？

n次元空間の構造みたいな話になっていきそうでアレだなぁ。

>>59がすでに証明できていれば良いのだが

BB(x+1)<BB(y+1)-BB(y)+BB(x)
=BB(x+1)<BB(x+2)-BB(x+1)+BB(x)
=2BB(x+1)<BB(x+2)+BB(x)
xが充分に大きければBB(x+1)<<<<<<<<<<<<<<<<<<<<<<<<<BB(x+2)
みたいになるからほぼ成り立つだろう

>>65
いや、58はそもそもBB(x+1)<<<<<<<<<<<<<<<<<<<<<<<<<BB(x+2)
を疑っているのだろう。
BB(x+1)-BB(x)>BB(y+1)-BB(y)
は無理かもしれないが、
BB(x+1)/BB(x)>BB(y+1)/BB(y)
くらいなら案外ありうるかも。

(2^3)/(2^2)=(2^2)/(2^1)

( ﾟдﾟ )

巨大数の定義は？

具体的に想像もできないくらい巨大な数。
俺定義。

どうも。BBすげえ強そうですね。どうでしょう、ひとまず無視しては(笑)。
前スレからHardy functionのもう少し堅いやつを拾ってきたので
性懲りもなくまた貼ります。言いだしっぺはあの人でした。懐かしい…

****
60 名前：有流才蔵 ：03/04/06 11:13
Hardy Function のHierarchyというのが面白そう。

以下、[]の0,a,λは順序数(ordinal)

H[0](x)=x+1
H[a+1](x)=H[a](x+1)
H[λ](x)=H[Λ(x)](x)

λは極限順序数、
Λ(x)はλに収束する基本列
(canonical fundamental sequence)

三行目はふぃっしゅ氏の"対角化"に似ているけれども
違うのは"Λ(x)"ってところ。

61 名前：有流才蔵 ：03/04/06 11:25
Hardy FunctionのHierarchyでいうと、
primitive recursive functionはH[ω＾ω]より小さく
multiply recursive functionはH[ω＾ω＾ω]より小さく
general recursive functionはH[ε0]より小さいそうだ。
（ε0とはω＾ω＾･･･なる順序数）

***

勝てない相手より、こっちの観戦がしたいです(他力本願)
対角化っていまだに何だか理解してないですから。ええ。

あー前スレで順序数の議論もやってたみたいですね。
アルゴリズムや定義論みたいなのに行ってしまいましたが。まあいいか。
巨大数スレ6のDATを募集中です。

コミケまで時間あるな…
チェーンの簡易表記の解説でもしようかな。

a→b→c→dをf(a,b,c,d)と表記されたのは画期的でした。

同じことな訳ですが、初見で面食らう方もいると思うので
定義の同じところだけ噛み砕こうと思います。

f(a)=a
これはチェーンでいえば何もない状態なので、a＝aってことです。

f(a,b)=a^b
これはa→bのことですね。つまりa→b＝a^bです。

f(a,…,x,y,1)=f(a,…,x,y)
これは、a→…→x→y→1と同じです。
チェーンの最後の数が1のときはこれを落とすことができるので、
a→…→x→y→1＝a→…→x→y　ということです。

f(a,…,x,1,z)=f(a,…,x)
同様に、a→…→x→1→zのことです。1より後ろは落とせるので
a→…→x→1→z＝a→…→x　となります。

f(a,…,x,y,z)=f(a,…,x,f(a,…,x,y-1,z),z-1)
a→…→x→y→zのことです。チェーンの定義より、

a→…→x→y→z
＝a→…→x→(a→…→x→(y-1)→z)→(z-1) となります。

まずはこれを踏まえて、いざリスト関数の解読！(どうだか…)
第一歩、こんな定義をしてる模様。
f((a,…,z),(1))=f(a,…,z)

ほら、なんとなく分かるかも？
続きは来年…

大晦日に久しぶりレス。

今Veblen関数とリスト構造を組み合わせた
巨大増加関数の案がまとまりつつあります。
（Veblen関数の変数中をリスト構造で表したものです。）
さらに一言付け加えるとすれば
リスト構造を順序数ωのように表すことができるようです。
これで順序数を大幅に拡張できます。
これを使ってナゴヤ関数をもっと詳しく
説明できるかもしれませんね。
さらにナゴヤ関数Ver２まで発展していきたいところです。

>>70
どうしても(＾ω＾)が見えてきてしまうのは俺だけか

↓うるせーんだよ
↓このスレを見ている人はこんなスレも見ています。(ver 0.20)

難し杉で議論に入れないナゴヤ関数ってなに？BBと比べるとどうなの？

あけましておめでとうございます。今年もちんたらやりましょう。
時に激しく。

で、73の続きですが、途中で分からない箇所があったので
(前スレで解決があったのかもしれませんが見てないです)、
わかるとこまで書きます。

>>77
ナゴヤ関数というのは現時点でも超強い関数、のはずです。
BBはすべての計算可能関数より強いので比較するまでもなく鬼強い、はずです。
(適当)

>>74
レス順ずれちゃいました。どもども。
現在前スレを読めないので、どの関数がどんなんだったか
サイトに記載した以外のものはド忘れしております。申し訳ない。
僕としては強いのが産まれれば何でもいいというか(BBは仕方ないもんなぁ)、
うまくまとまることを願ってやみません。またそれをイノセントな方々に
語り部として咀嚼するのが自分のささやかな使命、ってことでひとつ。

以前ロジシャンやプログラマの面々まで首を突っ込んで頂いた
well-defined がそもそも何だったのか、と(ヘボ)。
well-definedな関数でないと、何が起こってしまうのでしょうか。
なぜあの議論になったのかであるとか、結論などを記載していかないと
埋もれてしまうかな、と思ったり…

さて、リスト関数の続き。

f((a),(n))＝a なぜ個々に括弧？ つまり、　f(a,n)とすると
a→nという式と同じになってしまうので区別してる訳です。

f((a,b),(n))＝f((a,…,(b個),…,a),(n-1))
もうチェーンでは表現できないかな。でも怖くないですよ。たぶん…

f((a,…,x,y,1),(n))＝f((a,…,x,y),(n)) 最後の1が落ちただけです。

f((a,…,x,1,z),(n))＝f((a,…,x),(n)) これも1以下が落ちただけ。

f((a,…,x,y,z),(n))＝f((a,…,x,f((a,…,x,y-1,z),(n)),z-1),(n))
ここがミソです。
手前の(a,…,x,y,z)が化ける訳です。後ろ2つのy,zが。
zは(z-1)になるだけなので怖くないです。むしろyですよ。
yは、f((a,…,x,(y-1),z),(n))といった具合に肥大化します。

さて、いよいよリスト導入にいく訳ですが、
さっき入れた(n)、これが(*,…,*)という「リスト」に拡張されるという。

と、進む前に一応。nも他のaやzのように、こちらが数を決めて
ぶっこんでもよい、みたいです。つまり例えば、
f((4,6,2,3,5),(10))と書いても平気で、これは一意の巨大数として決まると。

で、(*,…,*)ですが、これがどういうニュアンスなのかちとわからんです。
(n)は1次で、2次以上だと(*,…,*)と書いて、リストと呼ぶってことなのかなぁ。
この次数がどう決まるのか、とかわからんです。
ひょっとしてf_nの定義から逆読みしていけばちゃんと決まるのかなぁ。

あと、m重リストってのは、
m＝1で(*,…,*)
m＝2で((*,…,*),(*,…,*))　みたいに続くのかな。
これらリストの次数は互いに異なってもいいのかな。あはん

>>81
(*,…,*)というのは、その前に(a,…,z)とか書いていたのと同じ意味です。
つまり、(*,…,*)は具体的には(31,41,5,9,2)とか(2,71,8)とか(6)のようなものです。

(1重)リストの定義はきちんと書けば下の通りです。
　{(a_1,a_2,…,a_n)|ｎは自然数; ∀i=1,…,n , a_iは自然数}
　nを要素の個数、a_iを(i番目の)要素と呼ぶ。
任意のリストを表す記号として(*,…,*)を使っています。(n)は要素が1個のリストです。

同様に、m重リストは下のように再帰的に定義します。
　{(L_1,L_2,…,L_n)|ｎは自然数; ∀i=1,…,n , L_iは(m-1)重リスト}
　注：L_iの要素の個数は互いに異なっていても構わない
2重リストなら((*,…,*),…,(*,…,*))となります。

f((a),(n))＝aというのは、((a),(n))という2重リストにfが作用していると見ることができます。
個々に括弧がついているのは、(a)と(n)が1重リストであることを示すためです。

>>82
1重リストは多分わかりました。(*,…,*)をきちんと書くとそうなるという
理解でいいのかしら。

2重リストはそうすると、定義が
{(L_1,L_2,…,L_n)|ｎは自然数; ∀i=1,…,n , L_iは1重リスト}
ですよね。
例えばn＝4なら
(L_1,L_2,L_3,L_4)　となって、L_1番目からL_4番目までリストが入ってると。
でもって、この4つのリストの要素の個数は互いに異なってもよいのですね。
つまり((4),(3,8,5,7),(2,9,3),(6,5))とかやっても大丈夫。

順番にやらないと分からん脳みそなので、次は3重リストの例も書きます。

3重リストの定義は、
{(L_1,L_2,…,L_n)|ｎは自然数; ∀i=1,…,n , L_iは2重リスト}　ということで、
例えばn＝5で書きましょう。5にしている意味は別にないです。
やはり見た目は(L_1,L_2,L_3,L_4,L_5)　となる訳ですが、今度は
L_1〜L_5が、それぞれ2重リストでなければならないみたいです。

ちょっと戻っていいですか。
1重リストにおいてn＝1のとき、
(L_1)　ただし L_1は自然数　

2重リストにおいてn＝1のとき、
(L_1)　ただし L_1は1重リスト　1重リストは(*,…,*)の形態をとる訳ですが、
この場合、1重リストの要素の個数にもn＝1を適用するかというと、そうではないと。
なぜなら、定義よりL_1の要素の個数が互いに異なってもよいから。

さて戻ります。さっき作った3重リスト
(L_1,L_2,L_3,L_4,L_5)　L_1〜L_5はそれぞれ2重リスト　ですが、
L_1〜L_5の要素(内包する1重リストの個数)も互いに異なってよい訳です。
ということは、
(((2,3,4),(5,6)),((7,8,9,8)),((7,6),(5),(4,3,2,3)),((4,5,6,7,8),(9,8)),((7),(6,5),(4),(3,2,3)))
とかどうでしょうか。大丈夫でしょうか。
(((7)))なんかも3重リストですか。

ということでm重リストもそんな感じでしょう(適当)。
リストがなんなのかを踏まえたということで、f関数のルールいきましょう。

原文で「リストの列」と呼ばれる(*,…,*),…,(*,…,*)を短縮して[L]と表記してみます。
ちなみにこいつは1重リストですね。(n)も同じく1重リストですが、ちょいと区別しときます。

では2重リストのf関数のルールを。

f([L],(1))＝f([L])
f([L],(1,b))＝f([L])
f([L],(a,b))＝f([L],(f([L],(a-1,b)),b-1))
f([L],(a,…,x,y,1))＝f([L],(a,…,x,y))
f([L],(a,…,x,1,z))＝f([L],(a,…,x))
f([L],(a,…,x,y,z))＝f([L],(a,…,x,f([L],(a,…,x,y-1,z)),z-1))

f([L],(1),(n))＝f([L])
f([L],(a),(n))＝f([L],(a))
f([L],(1,b),(n))＝f([L])
f([L],(a,b),(n))＝f([L],(a,…,a),(n-1)) ただしaはb個
f([L],(a,…,x,y,1),(n))＝f([L],(a,…,x,y),(n))
f([L],(a,…,x,1,z),(n))＝f([L],(a,…,x),(n))
f([L],(a,…,x,y,z),(n))＝f([L],(a,…,x,f([L],(a,…,x,y-1,z),(n)),z-1),(n))

最後の行、原文はf([L],(a,…,x,f([L],(a,…,x,y-1,z),n),z-1)とありましたが、
nに括弧がないのは誤植でしょうか。

括弧の展開は、例によって一番ケツから定義に従って開いていけばよいです。
こうしてみると、チェーンのお約束にリストがぶりぶりくっついた物体のように
見えないこともないかな、と。

さてm重リストのf関数は、こうです。

f(m重リストの列,(a,b),(n))=f(m重リストの列,((a,…,a),…,(a,…,a)),(n-1))
ただし((a,…,a),…,(a,…,a))はm重リストで、各リストの要素はb個。

[L]がm重になって、後のルールは概ね同様ってことでいいでしょうか。
そんな気がする年頃。

じゃあf_2関数いきましょう。
関数のルールが変わるだけです。びびらずに…

f_2の計算法はfとほとんど同じだが、下の式が違う。
f_2(a,b)=f((a,…,a),…,(a,…,a))
ただし((a,…,a),…,(a,…,a))はb重リストで、各リストの要素はb個。

f関数は、f(a,b)=a^bとなっていました。ここんとこを強化してる訳です。

この強化方式を悶々と拡張していった結果、こんな関数ができます。
f_n(a,b)=f_(n-1)((a,…,a),…,(a,…,a))

リストが何なのか分かれば、関数の構造自体は割とシンプルなようです。
しかしそれでいて、バード数がf_63(3,3)に到底及ばないという強力さ。

そんで思ったのは、関数がシンプルでこれだけ強いんだから、強化方式に
ふぃっしゅ系のなんかよくわからんアレをうまいこと組み込んだら
どんな感じでしょうか。有意でしょうか。

とりあえずこんな感じで…

>>84
最後の例はちゃんと3重リストになってます。
>>85
nには括弧が必要ですね。
>>86
これを書いたときは「三重以降も同様」で済むかと思ってましたが、
三重のときはもう少しきちんと書くべきだと思ったので次のレスで書いておきます。

バード数より大きくするには、実はf_2どころか3重リストを持ち出すまでもなく、
要素がたった3個の2重リストでも十分です。バード数＜f((3,3),(3,3),(3,3,2))

三重リストの計算法
f(((a,…,z)),((1)))=f(a,…,z)
f(((a)),((n)))=a
f(((a,b)),((n)))=f(((a,…,a),…,(a,…,a)),((n-1))) ただしaはb個,(a,…,a)もb個
f(二重リスト,((n)))で上記に当てはまらないときは、二重リスト部分を二重リストのみの時と同様に計算。

二重リストの列を[L2]と書くと、
f([L2],((1)))=f([L2])
f([L2],((1,b)))=f([L2])
f([L2],((a,b)))=f([L2],((f([L2],((a-1,b))),b-1)))
f([L2],二重リスト)で上記に当てはまらないときは、二重リスト部分を二重リストのみの時と同様に計算。

f([L2],((1)),((n)))=f([L2])
f([L2],((a)),((n)))=f([L2],((a)))
f([L2],((1,b)),((n)))=f([L2])
f([L2],((a,b)),((n)))=f([L2],((a,…,a),…,(a,…,a)),((n-1))) ただしaはb個,(a,…,a)もb個
f([L2],二重リスト,((n)))で上記に当てはまらないときは、二重リスト部分を二重リストのみの時と同様に計算。

特に分かりにくいのは、f(((*,…,*),(m)),((n)))のようになっているときに
(m)も((n))もそのままにして(*,…,*)の部分を計算することだと思います。
例えばf(((a,…,y,z),(m)),((n)))=f(((a,…, f(((a,…,y-1,z),(m)),((n))) ,z-1),(m)),((n)))

レスどうもです。改めて咀嚼しようと思います。サイト更新なども。
リストを使ったふぃっしゅ系関数との比較とかやれるもんなんでしょうか。

眠れないので過去ログを読んでいました。
僕が読み飛ばしてただけで、結構皆さんチェーン拡張の可能性を
探ってたんですね。当時は喧嘩ログばかり読んでたもんで…

懲りずにVeblen関数の定義を見ましたが、やはり模様にしか見えませんでした。

>>86
ということは
f_2(a,b)には(a,…,a)（aがb個の一重リスト）がb^b-1個あるということ？
気が遠くなる........
f_n(a,b)なんて化け物ですはい、僕にはf_n(a,b)=g(n,a,b)ぐらいしか次が思い浮かびません

最近このスレを知った初心者ですが、
初代スレから今までのスレで登場した色んな巨大数の大きさを
わかりやすくランキング形式でまとめてもらえまへんか？
とリクエスト

>>91
それはなかなか難儀なことなのです。総て挙げればかなりの量です。
各々の比較はいまだ途上ですし、好みや難易度などの問題もあります。
基本的にはスレが進むにつれ強力な関数が出てくるので、研究室のログを
全部読むと把握しやすいと思います。不明な点は聞けば誰かしら答えるかと。
産まれた経緯なんかも含めて面白いんです。

とりあえず、いま上に書いてある関数は相当強いですよ。

>>90の続き
さらにg(n,a,b)もg((a)(b)(c)(d)(e))みたいに多重リスト化していって
それを繰り返してf1_2(a,b)=f_2(a,b) f2_2(a,b)=g_2(a,b)
みたいに定義できたら.........う〜ん

>>93の続き
まあBBには勝てないと思うけどね

f_2(a,b)=f((a,…,a),…,(a,…,a))だと二重リストのように見えますね。
f_2(a,b)=f(((…(((a,…,a),…,(a,…,a)),…,((a,…,a),…,(a,…,a)))…)))とか書いた方が良かったかも。

>>90
一重リストの個数よりは、m重リストのmが大きいことの方がずっと重要です。
後で気付いたことですが、下のような式が成り立ちますし。
　f_2(a,b)=f(((…((a,b))…)),((…((2))…)))　(b+1)重リスト
この式には一重リストは2つしかありません。
こういう風に、無駄なところで頑張らずに単純かつ効果的な拡張を行うことが
巨大数作りには重要だと思います。

>>94
BB(n)は「ｎ文字のプログラムで計算できる最大の数」というのと似たような意味なので、
プログラムを書けるような関数を考えている時点でBBには勝てないはず。

>>95
増やしても大差ない列というのはありましたね。初期のふぃっしゅ関数の
改良の中でも。最小限で最高の効率を得るにはどうチョイスするかですが、
こういうのはやはり再帰的帰納なんとかを知らないといかんのでしょうか。
そういえばn重帰納云々の議論は埋もれましたね。結局は絶対安心な定義が
無かったんでしょうかあれは。

あと、ログ漁ってたら
＞無限順序数は有限の数ではないが、関数を定義すれば
＞有限の数はすぐに得られる
という発言がありました。そうなのですか。
長いこと揉めてますが、とりあえずのシンプルな
「ωを導入した、有限数を得る関数」を見たいです。
どういう仕組みで動くのか興味があります。

アッカーマン関数やチェーン表記が持っている最大の強みは、
A(x+1,y+1) = A(x,A(x+1,y))
a→...→x→y→z＝a→...→x→(a→...→x→y-1→z)→z-1
という定義だと思います。
ここには何重にも入れ子にする強さが隠れているわけで、リスト関数の定義でもこうした定義を使っています。
あとは、↑表記の持つ、並べることの強みを使っています。
そして、f_nの定義では、ふぃっしゅ数の持つ特徴のうちの一つである、
大元の関数をどんどん強くするという強みを使っています。
そう考えると、リスト関数は色々なものの長所を併せ持っていると言えるかもしれません。

>>93
リスト関数の拡張としては、f_nのnの部分を多重リストにするというのが考えられます。
たとえばf_(y,z)(多重リスト)=f_( f_(y-1,z)(多重リスト) ,z-1)(多重リスト)のようにして、
f_(多重リスト)という関数を定義するとか。
ただ、初めてリスト関数を書き込んだときにはあまり反響がなかったので、
それ以上先を考えることはしなかったけど。

多重リストに大小関係を導入すると、ωを用いるのと同様の順序関係が作れるようです。
ただ、ω^ω^nよりも先には進めませんでした。

(n)=(n,1)＜(1,2)=ω
　右側に1を付け足しても同じものとします。
　ただし、fの計算と違って(a,1,b)≠(a)です。途中に1があっても消せません。
　また、右側の数字が大きいリストの方が大きいとします。
　すると、(1,2)はどんな自然数nよりも大きいのでωと同一視できます。
(n+1,2)=ω+n
　一番左の数字にnを足すのは、順序数にnを足すのと同じとみなせます。
　すると、以下のような式が成り立ちます。
(1,3)=ω+ω=ω*2　(1,n+1)=ω*n　(1,1,2)=ω*ω=ω^2　(1,1,3)=ω^2+ω^2=ω^2*2
(1,1,1,2)=ω^2*ω=ω^3　(1,1,1,1,2)=ω^4
　多重リストの大小関係としては、右側のリストが大きい多重リストの方が大きいとします。
(1,1,1,1,2)=((1,1,1,1,2),(1))＜((1),(2))=ω^ω　((1),(3))=ω^ω+ω^ω=ω^ω*2
((1),(1,2))=ω^ω*ω=ω^(ω+1)　((1),(1,1,2))=ω^(ω+1)*ω=ω^(ω+2)
((1),(1),(2))=ω^(ω+ω)=ω^(ω*2)　((1),(1),(1),(2))=ω^(ω+ω)=ω^(ω*3)
(((1)),((2)))=ω^(ω*ω)=ω^ω^2　(((1)),((1),(2)))=ω^ω^2*ω^ω=ω^(ω^2+ω)
(((1)),((1),(1),(2)))=ω^(ω^2+ω*2) (((1)),((1)),((2)))=ω^(ω^2+ω*ω)=ω^(ω^2*2)
((((1))),(((2))))=ω^(ω^2*ω)=ω^ω^3　(((((1)))),((((2)))))=ω^ω^4
((…(1)…),(…(2)…))=ω^ω^n　ただし(n+1)重リスト

リスト関数fは、与えられた多重リストを上に述べた意味でより「小さい」多重リストに変換し、
最終的にどんなリストよりも「小さい」自然数に変換していると考えられます。
fは順序数(の一部)から自然数への関数ともみなせます。
もしもε_0やη_0を表すことができるリスト構造を作ることができたなら、
リスト関数をもっと強力なものに拡張できるのではないかと思います。

順序数の話はよく分からなくて読み飛ばしていたので、似たような構想は既にあるのかもしれませんが。

過去ログを読んでたら、
＞順序数を使う代わりに2変数にしたりするのが通常のやり方といえます。
＞（結果n変数になったりリストが入れ子になったりして行き詰まる）
という書き込みが見つかった。これって私が今陥っている状況そのものだろうか。

ちなみに、多重リストのm重リストを(m,2)重リストと表し、
多重リストの多重リストのm重リストを(m,3)重リストと表し、
…として（多重リスト）重リストなるものを定義したら、
ω＾ω＾…＾ω＾ωはリストとして表せました。でも、ε_0には到達できませんでした。
（どうしても（（…（（多重リスト）重リスト）…重リスト）重リスト）重リストから先に進めない）

(n)=(n,1)＜(1,2)=ω　　まさに目から鱗です。こういう作り方があるとは…
僕はこれだけで十分満足です。

試しに咀嚼してもいいですか。
まず、ここでの1重リスト(n)は、どう頑張ろうが有限の自然数です。
(最終的に ある関数f(n)がこの形から有限数を出力する必要があるため？
出口が無限では意味がなかろう、と勝手に理解。)

定義よりイコールなので(n,1)も有限の自然数です。

関数とリストがごっちゃになりそうですが、よーするにリストとは
記法の問題で、ルールに沿って展開していけばいつかは一意に定まった
数になりますから、つまりは数なんです。そうしましょう。

さて、前とは展開のルールが若干異なるようなので気を付けつつ…
新ルールは、右端の数(またはリスト)の大小を優先的に評価するからなのか、
途中の1は飛ばせない仕様になっているようです。
「右端の数(リスト)が大きいものが、大小関係で上に立つ」ルールにより、
(n,1)＜(1,2)　という不等式が書けます。
これはつまり、
[任意の大きさの自然数]＜(1,2)　ということです。
ここで(1,2)の1は飛ばせません。最もコンパクトな形になってます。
そして、(1,2)とは(n,1)より大きいリストのうち最小のものです。
繰り返しますが、リストとは1つの数です。すると…
(1,2)とは「任意の有限の数よりも大きい最初の数」ということになります。

そして「任意の有限の数よりも大きい最初の数」とは、ズバリωのことです。
だから(1,2)=ω　なんでございます。いかがでしょうか。

さて、関数で無限から有限に落とすとのことですが。やってみます。

f{4}(1,2)というものを考えてみました。
この関数f{m}(*)は、(*)がωを用いた式で表せる超限順序数だったとして、
ωをnに置き換えた式に自然数mを代入した値を出力するというものです。
(ヘボは承知なので、あまり突っ込まないように…)

したらばf{4}(1,2)は、(1,2)=ωなのでこれをnに引きずり落として、
nに4を代入して、そのまんまですが4が出力されます。

例2。
f{10}((1),(1,2))　

((1),(1,2))=ω^(ω+1)なのでn^(n+1)に引き下げてnに10を代入。
よって出力は10^11=100000000000　みたいな。

定義がやばい上に弱いですが、個人的に無限を組み込んだ関数から
有限の出力を得たので勝手に納得。
あまりにクルクルパーであればご指導ください。

>>101
途中の1を飛ばすと、多重リスト自体は「小さく」なります。
リスト関数では、多重リストをどんどん小さくしていく必要があるので、
途中の1を飛ばすことが許されるわけです。
一方、多重リストを順序数と対応させるときは、リストの「大きさ」が変わるような変化は許されません。
末尾の1が自由に付け外しできるのは、有限小数の末尾に無限個の0が省略されているのと同様に、
「多重リストの末尾には無限に1が並んでいるが、省略されている」と考えているからです。

再帰的に関数を定義するときは、ある引数がどんどん小さくならないときちんと定義されません。
リスト関数の場合は、リストそのものが小さくなっていく「引数」と考えられます。
「小さくなる」という考え方ができるということは「順序関係を持っている」ということであり、
順序数と対応付けられるのは自然なことなのかもしれません。

リスト関数をもう少し単純に定義してみます。

m重リストを表す括弧には_mをつけて表記する。（ただし_1は省略）
また、あるリストの唯一の要素となっている多重リストの括弧は省略する。
（例えば、((a,b))は(a,b)_2、((a),(b))は((a),(b))_2、(((n)))は(n)_3のように表記）

f(a)_m=a
f(a,b)_m=a^b

多重リストの要素に自然数の1または1のみを要素とする多重リストがあるとき、そこから右側の要素をすべて取り去る。

リストの右側のカンマから順番に見ていき、以下の表記に当てはまる最初のカンマに対し変換を適用する。
f(…y,z…)_m=f(… f(…y-1,z…)_m ,z-1…)_m
f(…(y),(z)…)_m=f(…(y,…,y),(z-1)…)_m　ただしyはy個
f(…(y)_n,(z)_n…)_m=f(…((y)_(n-1),…,(y)_(n-1))_n,(z-1)_n…)_m　ただし(y)_(n-1)はy個

f_n(a)_m=f_(n-1)((a)_(a-1),…,(a)_(a-1))_a　ただし(a)_(a-1)はa個

定義は以上です。以前のリスト関数と定義が一部変わっているので
二重リスト以上に対しては異なる値となりますが、
f(a,b,…,y,z)=a→b→…→y→zなことには変わりはありません。
これだと、>>100で述べた（多重リスト）重リストにも拡張しやすいと思います。

なんか僕が個人教授を受けているな雰囲気に…いや楽しいですが。

なるほど、1を飛ばす根拠はその辺りにあったのですね。ははあ。
しかし順序数をガチで学ぼうとするとZFCの公理系とかで即コケます。
全順序とか半順序とか、関係についてすら定義ありますもんね。うう…

>>104ではかなりスマートになりましたね。かつ明解。
軽く咀嚼を混ぜて改訂版を研究室に載せたいですね。

なんか自分の思いつくままに色々なことを書き連ねている気がします。

それはともかく、リストに対する別の見方について。
一重リストは、自然数から自然数への関数と対応付けることができます。
つまり、(a_1,a_2,…,a_n)というリストは、1→a_1, 2→a_2, …, ｎ→a_ｎ, ｎ+1→1, … という関数に対応付けられます。
もしも多重リストの(a_1,a_2,…,a_n)要素というのを、
n重リストのa_n番目の要素である、(n-1)重リストのa_(n-1)番目の要素である、…、
2重リストのa_2番目の要素である、1重リストのa_1番目の要素と定義すれば、
多重リストは一重リストから自然数への関数と対応付けられます。
同様に考えれば、多重リストから自然数への関数と対応付けられるリスト構造を考えることができます。
それは、>>100で少しだけ書いた(一重リスト)重リストと同じものです。
同様にして(多重リスト)重リスト、((一重リスト)重リスト)重リスト、…というリスト構造が作れます。

そして、リストと順序数の対応を考えて見ます。
ωより小さい任意の順序数は、自然数と対応付けできます。
ω^ωより小さい任意の順序数は、一重リストと対応付けできます。
ω^ω^ωより小さい任意の順序数は、多重リストと対応付けできます。
そして、ω^ω^ω^ωより小さい任意の順序数は、(一重リスト)重リストと対応付けできます。
すると、上で考えたリスト構造は、ε_0より小さい任意の順序数と対応付けできます。
ε_0から先を表すには、また別の工夫が必要でしょう。

つ前スレ
ttp://up.spawn.jp/file/up63970.lzh.html
かちゅの.datを圧縮しただけ　あとはまかせる

下手にごちゃごちゃしたリスト構造を作るより、
順序数表記をリスト構造の表記法とみなす方がいいように思えてきた。

ε_0より小さい順序数はω＾α*aの形の項の和として表されます。
>>106で多重リストの(*,…,*)要素という言い方を考えたのですが、
(*,…,*)の部分は指数αであり、要素の値は係数a+1となっています。
例えば、((1),(1,2))=ω^(ω+1)を考えると、指数はω+1=(2,2)、係数は1です。
リストを見ると、(2,2)要素が係数+1の2となっています。
このような見方をすれば、リスト関数は順序数の係数を変化させていく関数と言えます。

注：(a)というリストにはa-1という順序数を対応させないと自然な関係になりません。
　　つまり、(1)=0, (2)=1, (3)=2, …

ごめんなさい。>>104の定義はおかしいです。
　f((3,3),(2))_2=f((f((f((1,3),(2))_2,2),(2))_2,2),(2))_2
　=f((f((1,2),(2))_2,2),(2))_2=f((1,2),(2))_2=1
となってしまい、二重リスト以上で常に1になってしまいます。

リスト関数とHardy functionを比較してみました。
Hardy functionの定義は、大きく分けると下の二種類があるようです。
　F[0](x)=x+1
　F[α+1](x)=F[α]^x(x) （αは順序数）
　F[λ](x)=F[Λ(x)](x) （λは極限順序数、Λ(x)はλに収束する基本列）
　H[0](x)=x
　H[α+1](x)=H[α](x+1)
　H[λ](x)=H[Λ(x)](x)
FとHの間には、F[α](x)=H[ω^α](x)という関係が成り立つそうなので、以下ではFを使います。

順序数についての説明。
　自然数を小さい順に並べると、0,1,2,3,…となります。
　そして、あらゆる自然数よりも大きい「数」の中で最小のものをωと表します。
　ωのような「数」を導入しても順序関係は保たれるので、このような「数」を順序数と呼びます。

　ωよりも大きい順序数を順番に考えると、ω,ω+1,ω+2,ω+3,…のようになります。
　ω,ω+1,ω+2,ω+3,…のうちのどの順序数よりも大きい最小の順序数は、ω*2=ω+ωと書けます。
　このとき、ω,ω+1,ω+2,ω+3,…をω*2に収束する基本列と呼びます。
　この基本列をΛ(x)としたときには、Λ(x)=ω+xです。
　また、基本列を用いて定義した順序数を極限順序数と呼びます。
　同様に、ω*3=ω*2+ω, ω*4=ω*3+ω, …という順序数を考えることができます。

　そして、Λ(x)=ω*ｘという基本列を考えます。
　この基本列のどの数よりも大きい最小の順序数をω^2=ω*ωと書きます。
　ω*a+b(a,bは自然数)に対し、ω*a+b<ω*a+ω=ω*(a+1)<ω*ω=ω^2ですから、ω*a+b<ω^2です。
　そして、ω^2+1,ω^2+2,…と順に考えれば、ω^2+ω, ω^2+ω*ｎ, ω^2*2=ω^2+ω^2, ω^2*ｎが表せます。
　Λ(x)=ω^2*ｘを考えると、ω^3=ω^2*ωが表せます。
　同様にω^nを表し、Λ(x)=ω^xを考えればω^ωが定義できます。

　そしてω＾(ω+1)=ω^ω*ω, ω^(ω*2)=ω^(ω+ω), ω^ω^2=ω^(ω*ω)などを考えていけば、
　ω^ω^ω, ω^ω^ω^ω, ω^ω^ω^ω^ωなどが表せます。
　Λ(x)=ω^ω^…^ω^ω(ωはx個) としたときの収束先がε_0です。
　ω^ε_0という数を考えると、ω^Λ(x)=ω^ω^…^ω^ω(ωはx+1個)よりも大きい最小の順序数となりますが、
　これはε_0です。よってω^ε_0=ε_0という関係が成り立ちます。

細かい計算を書くと長くなるので省略しますが、
Hardy functionのF[α]でαに1を足すことは、リスト関数でxの右の数に1を足すことに相当します。
また、αにωを足すことは、リスト関数でxを一つ右に移動させることに相当します。
αにω＾2を足すことは、リスト関数でxの一つ右の一重リストの数に1を足すことに相当し、
αにω＾3を足すことは、リスト関数でxを一つ右の一重リストに移動させることに相当します。
一般に、αにω＾(2n)を足すことは、xの一つ右のn重リストの数に1を足すことに相当し、
αにω＾(2n+1)を足すことは、xを一つ右のn重リストに移動させることに相当します。
f_2を使うとn重リストのnをいくらでも大きくできるので、f_2はF[ω＾ω]に相当します。

結論として、f_(n+1)はF[ω^ω*n]に相当します。
過去ログによれば、ふぃっしゅ関数ver.1<F[ω^2]、ふぃっしゅ関数ver.2<F[ω^3]、
ふぃっしゅ関数ver.3はF[ω^ω*63]程度だそうなので、
f_64(3,3)はふぃっしゅ数ver.3程度の大きさということになります。

多重リストはω^ω^ωより小さい順序数に対応しますが、f_2≒F[ω^ω]=H[ω^ω^ω]なので、
リスト構造を拡張してε_0未満まで表せるようにしてもせいぜいH[ε_0]程度でしょう。
それならばリスト関数を使わずともHardy functionを使えばいいわけで、
リスト関数を拡張する意味はもはやないと思います。

それはともかく、このスレから読み始めた人向けの順序数やHardy functionの説明も必要でしょうね。
前スレでの順序数やHardy functionの説明はまとまってないので。

ログありがとうございます。
それにしても、えらいことになってきましたな…

巨大数を作るための方針についての考え。
今までは、
　急激に増加する関数を作る→関数を利用して巨大数を作る
という考えだったわけです。
ところが、多変数関数やリスト構造などを利用した大抵の関数よりもH[ε_0]の方が大きい。
それならば、巨大な順序数を作ってHardy functionを利用する方が簡単に大きな関数が作れます。
では、巨大な順序数を作るにはどうすればいいか。
それには、順序数から順序数への大きな関数を作ればいいわけです。つまり、
　急激に増加する順序数の関数を作る→関数を利用して巨大な順序数を作る
　→Hardy functionを利用して巨大数を作る
ということです。順序数の関数を作るには、Veblen関数を拡張するのがいいでしょう。
結局、これはナゴヤ関数と同じ考えです。
これから先、効率よく巨大数を作っていくためには、
順序数、Veblen関数、Hardy functionの理解が欠かせないと思います。

>>105
ZFCの公理系とか、全順序･半順序とかはひとまず無視しても支障はないかと思います。
ε-δ論法を知らなくても極限や微積分についてある程度理解はできるように、
そういうことを知らなくても順序数やVeblen関数、Hardy functionは理解できると思います。
ただ、Veblen関数やHardy functionについてのまとまった説明がないのが難しいところですが。

>>89
Veblen関数については、6-292の定義だけを見ても全く分からないと思います。
Veblen関数で定義される順序数への収束列というのを考えると理解しやすいでしょう。
以下の説明では具体例を書くと長くなるので、具体例は自分で考えてみてください。

α(n) (ただしnは自然数)という順序数の数列を考えたとき、
α(n)のどの項よりも大きい順序数の中で最小のものをαとすれば、
α(n)はαへの収束列です。ωへの収束列はω(n)=nとして考えます。

Veblen関数に入る前に、和や積に関する収束列を考えます。
以下では、βとγはそれぞれβ(n)とγ(n)の収束先になっているとします。
α=β+γのとき、α(n)=β+γ(n)とします。
α=β*(m+1) (mは自然数)のとき、α(n)=β*m+β(n)とします。

α=φ_0(γ)=ω^γとします。
γ=0のとき、α=ω^0=1なので収束列は考えません。
γ=γ'+1と表されるとき、α(n)=φ_0(γ')*n=ω^γ'*nとします。
α(n)の収束先は、ω^γ'*ω=ω^(γ'+1)=ω^γとなり、αに一致します。
γへの収束列がγ(n)のとき、α(n)=φ_0(γ(n))=ω^(γ(n))とします。

α=φ_(β'+1)(γ)とします。
γ=0のとき、α(0)=φ_β'(0)、α(ｎ+1)=φ_β'(α(n))という漸化式で定義します。
γ=γ'+1のとき、α(0)=φ_(β'+1)(γ')+1、α(ｎ+1)=φ_β'(α(n))とします。
γへの収束列がγ(n)のとき、α(n)=φ_(β'+1)(γ(n))とします。

βへの収束列がβ(n)のとき、α=φ_β(γ)とします。
γ=0のとき、α(ｎ)=φ_(β(n))(0)とします。
γ=γ'+1のとき、α(n)=φ_(β(n))(φ_(β)(γ')+1)とします。
γへの収束列がγ(n)のとき、α(n)=φ_(β)(γ(n))とします。

皆さん順序数やリスト関数についての説明ご苦労様です。

最初の案のナゴヤ関数はF[＊](x)の＊の部分が
2変数以上のリストのとき、HardyFunctionを利用して
順序数から巨大な順序数を作ることになるということです。
例えばF[1, 1](x) = F^x[ω](x) = F[F[ ... F[ω](ω) ... ](ω)](x)
となり、[ ]のネストで順序数ωから巨大順序数が作られます。
つまり、順序数→順序数変換の段階からHardyFunctionを
使っていることになります。

続き。

ところでHardyFunctionでは
F[ε0](x) >=(( ... m(x) ...)m(2)f)(x) となることがわかっているので
F[ε0](ω)はふぃっしゅ関数Ver5相当の巨大な順序数になります。
ということはVeblen関数を多変数に拡張してもF[ε0](ω)には
足元にも及ばないと思われます。
（それどころか(多重リスト)リストに拡張しても追いつかないと考えられる）
したがって、ナゴヤ関数はF[2, n](x)の段階で
多重リスト関数に拡張したVeblen関数を使ったHardyFunctionを
はるかに越える巨大増加関数になってしまいます。

ただ、現時点での問題として、F[ε0](ω)が
どの形の順序数で表されるかが問題になっています。
例えばF[1](x) = x + 1として、
F[ω](x) = x*2
F[ω*2](x) = x*2^x
F[ω*3](x) = ( ... (x*2^x)* ... )*2^(x*2^( ... (x*2^x) ...)) > x*2^^x
F[ω*2^ω](x) >= F[ω*ω](x) >= 2^^ ... ^^x = ak(2, x, x)
となり、途中で2^xとか2^2^ ... 2^xが出てくるところが曲者です。
今はF[λ(2^ω)](x) = F[λ(2^x)](x)としているところです。

順序数に対するHardy functionの定義をきちんと考えてみる必要がありそうですね。
順序数に対する演算は自然数に対する演算と性質が違うので、
単純にxとωを置き換えても、一意に定まる保障がありません。
例えば、1+x=x+1ですが、1+ω=ω≠ω+1です。
そして、2^ω=ωとなってしまいます。
2^ω=ωなのに2^xとxという違うものに置き換えてしまうと、一意的に定義されるのかが不安です。

もし、順序数に対するHardy functionの定義を最初に戻って考えるとすれば、
　H[0](x)=x　H[α+1](x)=H[α](x+1)
に対しては
　H[0](β)=β　H[α+1](β)=H[α](β+1)
とすればいいですが、
　H[α](x)=H[α_x](x)
に対しては、α_βが定義できなければ単純な置き換えはできません。
もしも、α_βはβが極限順序数のときにα_β_nの極限だとしてしまうと、α_ωはαそのものになります。
すると、H[α](ω)=H[α_ω](ω)=H[α](ω)となって定義されません。
なので、α_nのnを順序数に拡張することはできません。
かといって、H[α](β)をH[α_n](β_n)の極限としてもおかしくなります。
というのも、H[α](ω)はH[α_n](n)の極限ですが、
H[α_n](n)は自然数なのでその極限はωであり、H[α_n](ω)=ωとなってしまいます。
そして、H[α](β)をH[α_n](β)の極限としたときには、H[ω](β)=β+ωまではうまく定まるのですが、
H[ω+1](β)=β+1+ω=β+ωとなってしまい、これ以上大きくなりません。
こういった変なことを起こさずに、うまく順序数に対するHardy functionを定義できるのでしょうか。

順序数に対するHardy functionの定義をきちんと考えてみる必要がありそうですね。
順序数に対する演算は自然数に対する演算と性質が違うので、
単純にxとωを置き換えても、一意に定まる保障がありません。
例えば、1+x=x+1ですが、1+ω=ω≠ω+1です。
そして、2^ω=ωとなってしまいます。
2^ω=ωなのに2^xとxという違うものに置き換えてしまうと、一意的に定義されるのかが不安です。

もし、順序数に対するHardy functionの定義を最初に戻って考えるとすれば、
　H[0](x)=x　H[α+1](x)=H[α](x+1)
に対しては
　H[0](β)=β　H[α+1](β)=H[α](β+1)
とすればいいですが、
　H[α](x)=H[α_x](x)
に対しては、α_βが定義できなければ単純な置き換えはできません。
もしも、α_βはβが極限順序数のときにα_β_nの極限だとしてしまうと、α_ωはαそのものになります。
すると、H[α](ω)=H[α_ω](ω)=H[α](ω)となって定義されません。
なので、α_nのnを順序数に拡張することはできません。
かといって、H[α](β)をH[α_n](β_n)の極限としてもおかしくなります。
というのも、H[α](ω)はH[α_n](n)の極限ですが、
H[α_n](n)は自然数なのでその極限はωであり、H[α_n](ω)=ωとなってしまいます。
そして、H[α](β)をH[α_n](β)の極限としたときには、H[ω](β)=β+ωまではうまく定まるのですが、
H[ω+1](β)=β+1+ω=β+ωとなってしまい、これ以上大きくなりません。
こういった変なことを起こさずに、うまく順序数に対するHardy functionを定義できるのでしょうか。

二重に投稿されてますね。すみません。
Hardy functionのもう一つの定義である、
　F[0](x)=x+1　F[α+1](x)=F[α]^x(x)　F[α](x)=F[α_x](x)
を使えばうまく定義できそうです。
　F[0](β)=β+1
　F[α+1](β)=F[α]^β(β)
　F[α](β)はF[α_n](β)の極限(ただしβ<ωのときn=β)
ただし、F[α]^β(γ)は以下のように定義します。
　F[α]^0(γ)=γ
　F[α]^(β+1)(γ)=F[α](F[α]^β(γ))
　F[α]^β(γ)はF[α]^(β_n)(γ)の極限
こうすると、F[1](β)=β*2、F[2](β)=β*2＾β、F[3](ω)=ε_0となります。
ただ、F[3](ω)への収束列はω, ω^2, ω^ω, ω^ω^ω, …となり、
ε_0への普通の収束列とは少し異なります。

訂正
F[3](ω)への収束列はω, ω^2, ω^ω^2, ω^ω^ω^2, …です。
おそらく、β≧ω＾2ならば2＾β=ω^βだと思います。

今年に入ってから久々に盛り上がってますね
自分は全くの門外漢なので応援しつつ
スレの成り行きを見守らせてもらいます

>>121
再度訂正。
F[3](ω)への収束列はω, ω^2, ω^ω, ω^ω^ω, …で、
β≧ω＾ωならばたぶん2＾β=ω^βです。

とりあえず、6-510の書き込みを元に、勝手にナゴヤ関数の2変数リスト以下の場合を再定義してみます。
　L[1](x) = f(x)
　L[n+1](x) = f(L[n](x))
　L[ω](x) = L[x](x)
はそのまま使いますが、f(x)に対しては「順序数に対してもきちんと定義されているもの」という条件をつけます。
（例えばf(x)=x+1とか）
そして、収束列α_nの定められた極限順序数αに対して、
　L[α](x) = L[α_x](x)
　L[α+n+1](x) = L[α](L[α+n](x))
とします。リストが2項のときは
　L[2 , 1](x) = L[ω](x)
　L[2 , n+1](x) = L[L[2 , n](ω)](x)
　L[m+1 , 1](x) = L[m , ω](x)
　L[m+1 , n+1](x) = L[m ,L[m+1 , n](ω)](x)
とします。ここまでは、元の定義とほぼ同じです。
リストの右の数が順序数のときの定義は見当たらないようなので、
　L[2 , α](x) = L[α_x](x)
　L[2 , α+n+1](x) = L[L[2 , α+n](ω)](x)
　L[m+1 , α](x) = L[m , α_x](x)
　L[m+1 , α+n+1](x) = L[m ,L[m+1 , α+n](ω)](x)
としておきます。

すべきことは、xがωのときの定義と、極限順序数に対する収束列の定義です。
まず、ωの収束列はω_n=nとします。そして、xがωのときは以下のように定義します。
　L[1](ω) = f(ω)
　L[n+1](ω) = f(L[n](ω))
　L[ω](ω) は収束列が L[n](ω) の極限順序数
　L[α](ω) は収束列が L[α_n](ω) の極限順序数
　L[α+n+1](ω) = L[α](L[α+n](ω))
　L[2 , 1](ω) = L[ω](ω)
　L[2 , n+1](ω) = L[L[2 , n](ω)](ω)
　L[m+1 , 1](ω) = L[m , ω](ω)
　L[m+1 , n+1](ω) = L[m ,L[m+1 , n](ω)](ω)
　L[2 , α](ω) は収束列が L[α_n](ω) の極限順序数
　L[2 , α+n+1](ω) = L[L[2 , α+n](ω)](ω)
　L[m+1 , α](ω) は収束列が L[m , α_n](ω) の極限順序数
　L[m+1 , α+n+1](ω) = L[m ,L[m+1 , α+n](ω)](ω)
こうすれば、関数がきちんと定義されないということは避けられるはずです。

Veblen関数を拡張したものを定義してみました。
定義が長いので、とりあえず定義だけを書いておきます。

φ([α,β],[γ,δ],…,[ε,ζ])という形で表記する。
ただしα＞γ＞…＞εであり、φ(…,[α,0],…)=φ(…,…)とする。
φ([1,α],[0,β])=φ_α(β)、φ([2,1])=Γ_0である。
α=lim α_nと書いたとき、αはα_nを収束列とする極限順序数とする。

元のVeblen関数とΓ_0の定義。
　φ([0,0])=φ()=1
　φ([0,α+1])=lim φ([0,α])*n
　φ([0,α])=lim φ([0,α_n]) (φ([0,α])≠αのとき)
　φ([1,α+1],[0,0])=φ([1,α+1])=lim φ_n
　　ただしφ_0=φ([1,α]),φ_(n+1)=φ([1,α],[0,φ_n])
　φ([1,α+1],[0,β+1])=lim φ_n
　　ただしφ_0=φ([1,α+1],[0,β])+1,φ_(n+1)=φ([1,α],[0,φ_n])
　φ([1,α+1],[0,β])=lim φ([1,α+1],[0,β_n]) (φ([1,α+1],[0,β])≠βのとき)
　φ([1,α],[0,0])=φ([1,α])=lim φ([1,α_n]) (φ([1,α])≠αのとき)
　φ([1,α],[0,β+1])=lim φ([1,α_n],[0,φ([1,α],[0,β])+1])
　φ([1,α],[0,β])=lim φ([1,α],[0,β_n]) (φ([1,α],[0,β])≠βのとき)
　φ([2,1])=lim φ_n
　　ただしφ_0=φ(),φ_(n+1)=φ([1,φ_n])

αが後続順序数のとき。
　φ(…,[α+1,1])=lim φ_n
　　ただしφ_0=φ(),φ_(n+1)=φ([α,φ_n])
　φ(…,[α+1,1],[0,β+1])=lim φ_n
　　ただしφ_0=φ(…,[α+1,1],[0,β])+1,φ_(n+1)=φ([α,φ_n])
　φ(…,[α+1,1],[0,β])=lim φ(…,[α+1,1],[0,β_n]) (φ(…,[α+1,1],[0,β])≠βのとき)
　φ(…,[α+1,β+1])=lim φ_n
　　ただしφ_0=φ(…,[α+1,β])+1,φ_(n+1)=φ(…,[α+1,β],[α,φ_n])
　φ(…,[α+1,β+1],[0,γ+1])=lim φ_n
　　ただしφ_0=φ(…,[α+1,β+1],[0,γ])+1,φ_(n+1)=φ(…,[α+1,β],[0,φ_n])
　φ(…,[α+1,β+1],[0,γ])=lim φ(…,[α+1,β+1],[0,γ_n]) (φ(…,[α+1,β+1],[0,γ])≠γのとき)
　φ(…,[α+1,β])=lim φ(…,[α+1,β_n]) (φ(…,[α+1,β])≠βのとき)
　φ(…,[α+1,β],[0,γ+1])=lim φ(…,[α+1,β_n],[0,φ(…,[α+1,β],[0,γ])+1])
　φ(…,[α+1,β],[0,γ])=lim φ(…,[α+1,β],[0,γ_n]) (φ(…,[α+1,β],[0,γ])≠γのとき)
αが極限順序数のとき。
　φ(…,[α,1])=lim φ(…,[α_n,1])
　φ(…,[α,1],[0,β+1])=lim φ(…,[α_n,1],[0,φ(…,[α,1],[0,β])+1])
　φ(…,[α,1],[0,β])=lim φ(…,[α,1],[0,β_n]) (φ(…,[α,1],[0,β])≠βのとき)
　φ(…,[α,β+1])=lim φ(…,[α_n,φ(…,[α,β])+1])
　φ(…,[α,β+1],[0,γ+1])=lim φ_n
　　ただしφ_0=φ(…,[α,β+1],[0,γ])+1,φ_(n+1)=φ(…,[α,β],[0,φ_n])
　φ(…,[α,β+1],[0,γ])=lim φ(…,[α,β+1],[0,γ_n]) (φ(…,[α,β+1],[0,γ])≠γのとき)
　φ(…,[α,β])=lim φ(…,[α,β_n]) (φ(…,[α,β])≠βのとき)
　φ(…,[α,β],[0,γ+1])=lim φ(…,[α,β_n],[0,φ(…,[α,β],[0,γ])+1])
　φ(…,[α,β],[0,γ])=lim φ(…,[α,β],[0,γ_n]) (φ(…,[α,β],[0,γ])≠γのとき)

これで、lim φ_n (φ_0=φ(),φ_(n+1)=φ([φ_n,1]))を考えると非常に大きい順序数ができます。

式の展開を自動でやってくれるプログラム誰か作って。

>>127
マスマティカ

>>128
>>126の式なんかもOKなの？
あとフリーなのが良い…

>>125-126についての説明。
どの定義式もφ(…,[α,β],[0,γ])=という形をしていますが、
α,β,γに対して0 or 1,後続,極限の3通りを考えなければならないので式が27種類もできてしまいます。
(Γ_0=φ([2,1])の定義式は数えない)
うまくまとめれば式を12種類にまで減らせますが、それだとどの式を適用するか多少分かりづらくなります。

「φ(…,[α,β])≠βのとき」とかいうのは、例えばω^ε_0=ε_0で
左辺と右辺に別々の収束列を定義してしまうのを避けるためです。
右辺では1, ω, ω^ω, ω^ω^ω, …となりますが、
左辺ではω, ω^ω, ω^ω^ω, ω^ω^ω^ω, …と一つずれてしまいます。
もっとも、順序数は巨大数の計算のための道具に過ぎないと考えて
ω^ε_0≠ε_0としてしまっても、巨大数の計算をすることは可能です。
つまり、ω^ε_0やε_0は単なる収束列を表す記号に過ぎないという考えをとるわけです。
すると、収束列の異なる順序数は「別のもの」であるとみなせるわけです。
ω^ε_0=ε_0という性質は、関数の増加度を見積もるときに使えば十分なわけです。

>>126の最後の順序数でH[α](2)の計算をしたとすると、順序数の減り方は
φ([φ([1,1]),1])=φ([ε_0,1])→φ([ω^ω,1])→φ([ω^2,1])→φ([ω*2,1])→φ([ω+2,1])→
φ([ω+1,φ([ω+1,1])])→φ([ω+1,φ([ω,φ([ω,1])])])→φ([ω+1,φ([ω,φ([2,1])])])→
φ([ω+1,φ([ω,φ([1,φ([1,1])])])])=φ([ω+1,φ([ω,φ([1,ε_0])])])→
φ([ω+1,φ([ω,φ([1,ω^ω])])])→φ([ω+1,φ([ω,φ([1,ω^2])])])→
φ([ω+1,φ([ω,φ([1,ω*2])])])→φ([ω+1,φ([ω,φ([1,ω+2])])])→
φ([ω+1,φ([ω,φ([1,ω+1],[0,φ([1,ω+1],[0,φ([1,ω+1])])])])])→
φ([ω+1,φ([ω,φ([1,ω+1],[0,φ([1,ω+1],[0,φ([1,ω],[0,φ([1,ω],[0,φ([1,ω])])])])])])])→
φ([ω+1,φ([ω,φ([1,ω+1],[0,φ([1,ω+1],[0,φ([1,ω],[0,φ([1,ω],[0,φ([1,2])])])])])])])
=φ([ω+1,φ([ω,φ([1,ω+1],[0,φ([1,ω+1],[0,φ([1,ω],[0,φ([1,ω],[0,η_0])])])])])])→
…となり、入れ子構造がすごいことになるのが分かります。

ω^ε_0やε_0は単なる収束列を表す記号だという考え方について。
Hardy Functionに順序数を入れるときは、極限順序数は収束列のx番目の項に置き換えるわけです。
ならば、Hardy Functionを使う分には極限順序数と収束列は一対一に対応するものとみなせます。

では、1+ω=ω≠ω+1のような、順序数に対する等式は何を意味するのでしょうか。
これは、Hardy Functionに入れたときの関数の増加度を表しています。
F[1+ω](x)=F[1+x](x), F[ω](x)=F[x](x), F[ω+1](x)=F[ω]^x(x)という三つの関数を考えたとき、
F[ω](x)＜F[1+ω](x)＜F[ω](x+1)となるので、この二つの関数の増加度はほぼ同じです。
一方、F[ω](x)とF[ω+1](x)では明らかに増加度が違います。
なので、急激に増加する関数を作りたいときは、順序数の大きさをちゃんと考えなければいけません。

でも、順序数の大きさが分からなくても計算することだけならできます。
順序数を使った関数の計算法を理解したいだけなら、
「極限順序数と収束列が一対一に対応する」という不正確な理解でも十分です。

以前の定義は間違っているところがあったので、書き直しました。
順序数を知らない人は「極限順序数」を「数列」と読み替え、
limは無視して「左辺の記号＝右辺の数列」だと思えば理解できると思います。
　α=lim φ_nと書いたとき、αは極限順序数、α_n=φ_n
　βが極限順序数のとき
　　α+β=lim α+β_n
φの定義(Veblen関数の拡張)
　　φ(…,[α,0],…)=φ(…,…)
　　φ()=1
　　φ([0,α+1])=lim φ_n
　　　ただしφ_0=0,φ_(n+1)=φ_n+φ([0,α])
　　φ(…,[α+1,1],[0,β+1])=lim φ_n
　　　ただしφ_0=φ(…,[α+1,1],[0,β])+1,φ_(n+1)=φ(…,[α,φ_n])
　　φ(…,[α+1,β+1])=lim φ_n
　　　ただしφ_0=0,φ_(n+1)=φ(…,[α+1,β],[α,φ_n])
　β≠0のとき
　　φ(…,[α,β+1],[0,γ+1])=lim φ_n
　　　ただしφ_0=φ(…,[α,β+1],[0,γ])+1,φ_(n+1)=φ(…,[α,β],[0,φ_n])
　αが極限順序数のとき
　　φ(…,[α,1],[0,β+1])=lim φ(…,[α_n,1],[0,φ(…,[α,1],[0,β])+1])
　　φ(…,[α,β+1])=lim φ(…,[α,β],[α_n,1])
　βが極限順序数のとき
　　φ(…,[α,β])=lim φ(…,[α,β_n])
　　φ(…,[α,β],[0,γ+1])=lim φ(…,[α,β_n],[0,φ(…,[α,β],[0,γ])+1])
Fの定義(Hardy function)
　　F[0](x)=x+1
　　F[α+1](x)=F[α]^x(x)
　αが極限順序数のとき
　　F[α](x)=F[α_x](x)
巨大関数の定義
　f(x)=F[φ_x](x)　ただしφ_0=0,φ_(n+1)=φ([φ_n,1]))

>>132
小さい値について計算してみると、こうなります。
f(0)=F[0](0)=1
f(1)=F[φ([0,1])](1)=F[1](1)=F[0](1)=2
f(2)=F[φ([φ([0,1]),1])](2)=F[φ([φ([0,1]),0],[2,1])](2)=F[φ([2,1])](2)=F[φ([2,0],[1,φ([2,0],[1,0])])](2)
=F[φ([1,φ()])](2)=F[φ([1,1])](2)=F[φ([1,0],[0,φ([1,0],[0,0])])](2)=F[φ([0,φ()])](2)=F[φ([0,1])](2)
=F[2](2)=F[1]F[1](2)=F[1]F[0]F[0](2)=F[1](4)=F[0]F[0]F[0]F[0](4)=8

この関数はH[Γ_0]よりもずっと大きい関数なので、このスレで今まで出てきた関数の中では
ナゴヤ関数とBBを除くどの関数よりも急激に増加するはずです。
BBは計算可能などの関数よりも大きいので、当然この関数よりも大きいです。
ナゴヤ関数は、順序数にHardy functionを適用するとどの位大きくなるか見積もらないと比較できません。
リスト構造で比較してみると、ナゴヤ関数Ver.1は”自然数”個の変数を使っているのに対し、
この関数では[α,β]を「α番目の要素がβ」という意味で解釈しているので、
ある意味では”順序数”個の変数を使っていることになります。
見た目はただの2重リストですが、要素が順序数なので自然数を要素とする2重リストよりは
はるかに複雑な構造となります。
>>116では"Veblen関数を多変数に拡張してもF[ε0](ω)には足元にも及ばない"と書いてありますが、
F[ε0]はあくまでも「自然数のリスト構造」を変数とする関数より大きいだけで、
「順序数のリスト構造」となるとそうは言い切れないと思います。

>>133
考察乙です

Hardy functionを順序数に適用したらどうなるかを>>120の定義を用いて計算してみると、
どうやらF[α](β)≒φ_α(β)となりそうです。α＜ω*2の場合しか確かめてませんが。
少なくとも、F[ω+n](φ_[ω+n](α))=φ_[ω+n-1](φ_[ω+n](α)*2)という式が成り立ちます。
Veblen関数は、実はかなり巨大な順序数を作り出せる関数のようです。

この推測に基づいてナゴヤ関数と>>132の関数を比較すると、
L[α,β](ω)≒φ([2,1],[1,α],[0,β])ということになるようです。
(左辺はナゴヤ関数、右辺は>>132の拡張Veblen関数)
もし、L[a_n, …, a_0](ω)≒φ([n,a_n],…,[0,a_0])という関係が成り立つのなら、
ナゴヤ関数Ver.1より>>132の関数の方が大きいということになります。
でも、ナゴヤ関数Ver.2はずっと巨大なものになるそうなので、
>>132を上回るような関数になることを期待しています。

それと、上の記述はかなり推測が入っているので、間違いがあるかもしれません。

>>132の定義式で、
　β≠0のとき
　　φ(…,[α,β+1],[0,γ+1])=lim φ_n
　　　ただしφ_0=φ(…,[α,β+1],[0,γ])+1,φ_(n+1)=φ(…,[α,β],[0,φ_n])
　αが極限順序数のとき
　　φ(…,[α,1],[0,β+1])=lim φ(…,[α_n,1],[0,φ(…,[α,1],[0,β])+1])
の式を、
　　φ(…,[α+1,β+1],[0,γ+1])=lim φ_n
　　　ただしφ_0=φ(…,[α+1,β+1],[0,γ])+1,φ_(n+1)=φ(…,[α+1,β],[α,φ_n])
　αが極限順序数のとき
　　φ(…,[α,β+1],[0,γ+1])=lim φ(…,[α,β],[α_n,φ(…,[α,β+1],[0,γ])+1])
に訂正します。

今のところ、BB以外の計算可能な巨大数については
ナゴヤ関数なるものが最強候補なわけですな

>>137
そういうことですね。ただ、ナゴヤ関数は>>117のように定義が怪しいところもあるようです。
その点では、>>132、>>136の関数はちゃんと定義できていてナゴヤ関数Ver.1より大きいようなので
現時点では最強なのかもしれません。自分で言っても説得力はありませんが。
>>132、>>136の関数の定義がよく分からない人がいたら聞いてください。

拡張Veblen関数による順序数の大小関係
α=φ(…,[β,γ],…)のとき、γをαのβ成分と呼ぶ。
γ=φ(…)のとき、α＜γ,β＜γならばα+β＜γ
β=φ(…)のとき、α＜βならばα+β=β、α≧βならばα+β＞α,β
α=φ(…),β=φ(…)のとき、αのγ成分＞βのγ成分 となるγが存在して、
　δ＜γならばα＞βのδ成分 であり、ε＞γならば αのε成分=βのε成分 が成り立つとき、α＞β
α=φ(…,[β,γ]),γ=φ(…)のとき、δ＜βならば αのδ成分=0 であり、
　ε＞βならば αのε成分≦γのε成分 であり、
　ζ＞β、αのζ成分＜γのζ成分 となるζが存在するならばα=γ

上記のような大小関係が成り立つように、>>132、>>136で収束列を定めてあります。
ただし、上の式での=は順序数として等しいだけで、>>132、>>136で定義される収束列は異なるので、
>>132、>>136の関数の計算で=とすることはできません。

また、上の大小関係を見ると0以外の自然数が出てきていませんが、
0より大きくφ()よりも小さい数が存在しないとしても矛盾は生じないので
φ()を1とみなせることが分かります。

巨大数と直接は関係ない話ですが、>>139の大小関係に以下の基本的な定義を加えれば、
0に+,φを次々に適用して得られる数の集合(仮にΦと呼ぶ)に対し順序関係がきちんと定まるはずです。
　(α+β)+γ=α+(β+γ)
　α+0=0+α=αをみたす元0が存在する
　任意のα,βに対しα＞β,α=β,α＜βのうちいずれか一つのみが成り立つ
　α＜β,β＜γならばα＜γ
また、厳密に+やφという演算を定義すれば、
　+:Φ×Φ→Φ; (α,β)├→α+β
　E={e:Φ→Φ; α├→e(α)|Ψ⊂Φ, α∈Ψでなければe(α)=0}として
　φ:E→Φ; e├→φ(…,[α,e(α)],…,[β,e(β)],…) ただしα,β∈Ψ, α＞β
ただし、eはαに対しα成分を与える写像です。

こんな説明は理解しなくても>>132、>>136の関数は理解できるはずですが、
この関数について詳しく知りたい人がいたときのために書いておきます。

>>140
一つ抜けてました。Ψは要素が有限個の集合です。
0＜φ()というのは、以下のように導けます。
0≧φ()とすると>>139の4行目より0+φ()＞0
ところが0+φ()=φ()であるからφ()＞0となり矛盾する　よって0＜φ()

どうも。のろのろと勉強しております。

F[λ](x)=F[Λ(x)](x) （λは極限順序数、Λ(x)はλに収束する基本列）

ここのくだりが長いことわからなかったのですが、要するに
例えばλ=ωの場合であれば Λ(x)=x　なので
F[ω](x)=F[x](x)　のようになるんでしょうか。

λ=ω*2の場合は　Λ(x)=ω+x　より
F[ω*2](x)=F[ω+x](x)
これはここからどう展開するのか分からんです。(そもそも合っているのか)

ちなみに英語サイトに、ωは最小の極限順序数である、という
記述があったのでそういう理解をしております。荒っぽいでしょうか。

＞The first limit ordinal is ω.

「最小の超限順序数」ではなくて？

>>143
ただ、0を極限順序数とする人も多いよ

limit ordinalってのはsuccessor ordinalじゃないというのが定義だったような。
だとしたらそれで良いはずですけど。

別にどういう用語を使っても良いだろうけど「超限」ってのは
transfiniteの訳語として使うことが一般的じゃないのかな。
しかし超限ってどういう意味ですか、と聞かれるとちょっと困りますね

wikipediaに「極限順序数(limit ordinal)」という記載があったので
英語で検索したところ、
http://mathworld.wolfram.com/LimitOrdinal.html
ここにそういう記載がありました。

超限順序数を英語で何と呼ぶのかが見つかっておりません。
wikipediaではωは最小の超限順序数であるとも書いてありますね。
謎は置いておいて、目先の疑問に触れてみた、ということでひとつ。

＞自然数でない序数を transfinite ordinal という。

との記述を発見。でも序数って「first」「second」みたいなもんですか？
むう…

さらに怪しい翻訳。謎。

正の整数の超限順序数はωによって指定されます。

性懲りもなく。

＞超限数は，超限順序数と超限基数に分かれる

ここでの運用を勝手に推測すると、ωは極限順序数であるし、また
超限順序数でもあるから混乱を避けるため呼称を統一した、とか？
あるいは、極限順序数の定義でいかないと基本列のカラクリが使えないとか。
妄想です。

>>149
それは、「正の超限順序数をωと表すとする」って約すのが正解。
「傾きをvとおく」みたいなものだ。

日本語版wikipediaには、
＞有限整列集合から定義される順序数を有限順序数といい、
＞そうでないものを超限順序数と呼ぶ。
という記述がありますが、超限というのはおそらく、
0,1,2,3,･･･として定義できる"限"界を"超"えた数という意味ではないでしょうか。

>>142
[ ]の中の数を一つ減らしてx回繰り返します。
xに具体的な数字を入れてやってみると、
　F[ω*2](1)=F[ω+1](1)=F[ω](1)=…
　F[ω*2](2)=F[ω+2](2)=F[ω+1](F[ω+1](2))=…
　F[ω*2](3)=F[ω+3](3)=F[ω+2](F[ω+2](F[ω+2](3)))=…
　F[ω*2](4)=F[ω+4](4)=F[ω+3](F[ω+3](F[ω+3](F[ω+3](4))))=…
ということになります。x=2の場合でもう少し先までやってみると、
　F[ω+1](F[ω+1](2))=F[ω+1](F[ω](F[ω](2)))=F[ω+1](F[ω](F[2](2)))
　=…=F[ω+1](F[ω](8))=F[ω+1](F[8](8))=…
となります。( )の中身が計算されてからωを置き換えるので、
F[ω]が入れ子になると外側ほど大きな数で置き換えられることになります。

個人的なイメージとしては、
超限が先にあるものじゃなくて、
ω以上の順序数を「超限順序数」と呼ぶみたいな印象が

>>151
訂正ありがとうございます。0を極限順序数とするというのは、
主張の問題であって算術的には問題ないのでしょうか。

＞0=α+1となるような順序数αは存在していませんので、0は極限順序数
こんなん拾いました。ということは0も順序数ということでいいですか。

>>152
とりあえず僕は「極限順序数」と呼んでおくことにします。
さて上の続きを書いてみますが、

F[ω*2](2)=F[ω+2](2)=F[ω+1](F[ω+1](2))=F[ω+1](F[ω+1](F[ω](2)))
=F[ω+1](F[ω+1](F[2](2)))

ここでF[2](2)としていいのか分かりませんが続けます。
F[2](2)=F[1]^2(2)
=F[F[1](2)](2)
=F[F[0]^2(2)](2)
=F[F[F[0](2)](2)](2)
=F[F[3](2)](2) …　　　

元の式に戻ると、　F[ω+1](F[ω+1](F[F[3](2)](2)))
あれ、またヘマやったかな？

研究室に巨大数スレ6のログを丸ごとぶち込みました。
暇潰しにどうぞ。

>>154
0はもちろん順序数だよ。
というか、自然数は全部、順序数。
順序数は自然数の概念を無限の領域まで拡張したみたいな感じのもの

>>156
解説ありがとうございます。0が自然数に含まれるのか分からなかったのです。

前スレをちんたら読んでおります。
魚スキー氏曰く、Hardy functionについて、

H[ω](x)=H[x](x)=2x+1
H[ω+n](x)=H[ω](x+n)=2x+2n+1
H[2ω](x)=H[ω+x](x)=4x+1
…… H[nω+ω](x)=H[nω+x](x)=H[nω](2x) なので
H[nω](x)=2^n*x+1
……ω^2の基本列は{ω, 2ω, 3ω, ...}
H[ω^2](x)=H[ωx](x)=2^x*x+1
H[ω^2+ω](x)=H[ω^2](2x)=2^(2x)*2x+1
H[ω^2+2ω](x)=H[ω^2+ω+x](x)=2^(4x)*4x+1
H[ω^2+nω](x)=2^(2^n*x)*2^n*x+1
H[2ω^2](x)=H[ω^2+ωx](x)=2^(2^x*x)*2^x*x+1

との結果を得ているようで、僕はヘボなのでプロセスが分かりません。
H[x](x)=2x+1　となる理由すら。うはは

うーん、自分ナゴヤ関数の咀嚼に挑んでたのか…
全く記憶にない(笑)

ω＝α+1になる順序数αは存在しないから極限順序数。
ってことでいいのだろうか。

>>154
F[ω+1](F[ω+1](2))=F[ω+1](F[ω+1](F[ω](2)))ではなく、
F[ω+1](F[ω+1](2))=F[ω+1](F[ω](F[ω](2)))です。
それから、F[α+1](x)=F[α]^x(x)というのは[ ]の中に入れ子にするのではなく、
( )の中に入れ子にします。そうしないと[ ]の中の数が減らないので
永久に計算が終わりません。
F[2](2)=F[1](F[1](2))=F[1](F[0](F[0](2)))=F[1](F[0](3))=F[1](4)
=F[0](F[0](F[0](F[0](4))))=F[0](F[0](F[0](5)))=F[0](F[0](6))=F[0](7)=8
となります。

>>157
HとFでは定義が違うことに注意しなければいけませんが、6-303には、
　H[0](x)=x+1
　H[1](x)=H[0](x+1)=x+2
　H[n](x)=H[0](x+n)=x+n+1
と書いてあります。一行目と二行目は定義に当てはめただけです。
H[a+1](x)=H[a](x+1)の式を見ると、[ ]の中の数を1減らして
( )の中の数を1増やしています。これをn回繰り返すと、
H[n](x)は[ ]の中の数がｎ減って( )の中の数がn増えるので、
H[n](x)=H[0](x+n)となります。H[0]の定義を使えばH[n](x)=x+n+1となります。
この式は、nがどんな自然数でも成り立つので、nをxに置き換えてもかまいません。
すると、H[x](x)=x+x+1=2x+1となります。
以下も同様で、「n回繰り返す」ということをやってnを含む式を導いてから、
「nをxに置き換える」ということをやっています。

>>160
わざわざすみません。過去ログですっ飛ばしてるような初歩的なことばかりで。

F[ω+1](2)=F[ω](F[ω](2))　は了解しました。昔ながらの入れ子をやってしまいました。

＞一行目と二行目は定義に当てはめただけです
まんまですね。びびりすぎでした。

＞「n回繰り返す」ということをやってnを含む式を導いてから、
＞「nをxに置き換える」
H[n](x)=x+n+1　もガッテンです。ここから
H[x](x)=x+x+1=2x+1　や、それ以降が出てくる訳ですね。どれどれ。

H[ω+n](x)=H[ω](x+n)=H[x](x+n)=2x+n+1

H[2ω](x)=H[ω+x](x)=H[ω](2x)=H[x](2x)=3x+1

…なんか前述の解と違っておるのですが、まだ勘違いしているのでしょうか、僕は。

>>161
＞H[ω](x+n)=H[x](x+n)
＞H[ω](2x)=H[x](2x)
の部分ではωをxではなく、( )の中身に置き換える必要があります。つまり、
　H[ω](x+n)=H[x+n](x+n)=2(x+n)+1=2x+2n+1
　H[ω](2x)=H[2x](2x)=4x+1
となります。

>>162
なんとなく分かったような気がします。
H[ω](x+n)　においては基本列がΛ(x+n)になるから、ということでしょうか。
基本列と呼ぶからには列なんだと考えてしまうのですが、ひとかたまりの
ものとして振舞いますよね。収束と対応しているから同値ということでしょうか。
そもそもなぜ列がΛ(x)として表現できるのかがいまいち…

>>163
基本列は順序数の数列だと考えればいいです。
数列を{a_n}と書くように、基本列をΛ(x)と書いています。
数列でnの部分に相当するのが基本列でのxです。
ただ、数列でa_n(つまり一つの項)に相当するものもΛ(x)と書いています。
　H[λ](x)=H[Λ(x)](x)　(Λ(x)はλに収束する基本列)
と書いてあるとき、左のΛ(x)はa_nの意味で、右のΛ(x)は{a_n}の意味です。
これは、f(x)が「関数」そのものを表すこともあれば、
「関数にxを代入した値」を表すこともあるのと同じです。

>>164
なるほど、数列の一般項が自然数の関数であるようなものですか。
また解読できるログが増えるといいなぁ…

>>110のHardy functionの定義で
H[0](x)=x　というのはH[0](x)=x+1の誤植でしょうか。

それと、F[ω+x](x)を展開する場合、ω+xは極限順序数ではないので
(xは自然数なのでω+(x-1)が存在してω+x=ω+(x-1)+1となる)、
F[ω+x](x)=F[ω+(x-1)]^x(x)　とすべきでしょうか。

またやっちまった予感…

自己レス。誤植ではありませんでした。

>>166
x≠0のときはそれで合ってます。
x=0のときも考えるならば、F[ω+0](0)=F[ω](0)=F[0](0)=0+1=1となります。

>>168
どうもありがとうございます。
ようやくHardy functionのビギナー(僕もですが)向け説明文を
一通り記述したので、研究室の方にupした際は添削して頂ければ
幸いです。推敲がまだなので後日…

6-713を読んでみました。大体の流れとしては、
　φ_α(β)≒ak(ω,β,α)
Γ_0はφ_{*}(0)にω回入れ子にすれば得られるはずだから
　Γ_0≒ak^ω(ω,ω,*)
そして、>>116ではアッカーマン関数よりF[ε_0]の方が急激に増加するはずだから
　F[ε_0](ω)＞Γ_0＞Veblen関数で定義される数
としているのだと思います。
一方、>>135での私の見積もりでは、
　F[ε_0](ω)≒φ_ε_0(ω)＜Γ_0
ということになってしまいます。
こうなってしまう原因としては、「アッカーマン関数よりF[ε_0]の方が急激に増加する」というのは
変数が自然数のときのみ成り立つことで、変数が順序数だと成り立たないというのが考えられます。
例えば、2^xの方がx^2より急激に増加しますが、2^ω＜ω^2です。
これを見ると、順序数の関数の大小比較は簡単にはできないというのがわかります。

>>132、>>136でのVeblen関数の拡張は、6-714での拡張とほぼ同じもののようです。
ただ、>>132、>>136では「順序数」個の変数を使っていることになりますが。

関数と表記法のページにHardy functionを追加しました。
さてVeblen functionの入り口にやってきた、と思ったら…

>>170
無限順序数の演算は交換法則が成り立たないんですよね。
それだけ知ってます。手を出すとやばそうなので見守ります。

ところで、Veblen functionの
φ_1(0)=ε_0　を導いてみたんですが、左辺は
φ_(β'+1)(γ)の形をとっているので　β'=0 γ=0　とおいて、
γ=0のとき、α(0)=φ_β'(0)、α(ｎ+1)=φ_β'(α(n))という漸化式を定義。
すると
α(0)=φ_0(0)=1
α(ｎ+1)=φ_0(α(n))=ω^α(n)　を得る。この数列は
1,ω,ω^ω,ω^ω^ω,…　となるので、収束先はε_0となる。

というのはいかがでしょう。

>>172
それで合ってますね。Veblen関数については、以下のような見方もできます。

Veblen関数の定義は、φ_(α+1)(β)=「φ_α(γ)=γとなるβ番目の数」ということですが、
これは、「ある順序数γより小さい数に+,φ_0,φ_1,…,φ_αを何回適用してもやはりγより小さい」
という条件を満たすγのうちβ番目のものと見ることができます。
「 」の条件は、「γより小さい数は+,φ_0,φ_1,…,φ_αという演算について閉じている」
と言い換えることもできます。

もう少し具体的な例で考えてみると、φ_0(α)=ω^αより小さい数はいくら足し合わせても
φ_0(α)=ω^αより小さな数となります。
例えば、α=0のときはω^0=1より小さい数は0しか存在せず、
0をいくら足し合わせても1よりは小さいことから、
1が「その数より小さい数は+について閉じている」ような0番目の(最初の)数ということになります。
α=1のときは、ω^1=ωより小さい数(つまり自然数)をいくら足し合わせても
ωよりは小さいということになります。これを逆に考えると、自然数をいくら足し合わせても
到達できないような最小の数をφ_0(1)=ωとして定義していることになります。
この考え方でα=2としてみると、φ_0(2)は2番目の数であるため
1番目の数であるωよりは大きな数となります。なので、自然数やωをいくら足し合わせても
到達できないような最小の数を考えると、それはω*nの収束先であるω^2ということになります。

φ_1(0)=ε_0で考えると、ε_0より小さい数に+やφ_0を何回適用しても
ε_0より小さいということになります。逆に考えれば、0に+やφ_0を何回適用しても
到達できないような数のうち、最小のものをφ_1(0)=ε_0と定義していることになります。
φ_1(1)=ε_1は、ε_0以下の数(ε_0も含む)に+やφ_0を何回適用しても到達できない
最小の数ということになります。

このように、+だけでは到達できない数をφ_0で定義し、+とφ_0だけでは到達できない数をφ_1で定義し、
+とφ_0とφ_1だけでは到達できない数をφ_2で定義し、…とやっていって、
最終的にはVeblen関数を何回使っても到達できない最小の数をΓ_0と定義していることになります。

すごく面白そうなんだが、いかんせん俺には難しすぎ…。

>>174
最近はかなり解説が咀嚼されていますので、研究室のHardyと合わせて
読んでみて下さい。ヘボの僕でもVeblenまで追い付くことができました。
些細な疑問でも書いて頂ければ、優しい人が丁寧に教えてくれます。
(他力本願…)
個人的な印象では、リスト関数の解読よりは物量的に楽だと思いました。
変な文字達とお友達になれれば、結構すぐですよ。

言ったそばから質問でございます。Veblenの解説を書いているのですが、

＞βへの収束列がβ(n)のとき、α=φ_β(γ)とします。
＞γ=γ'+1のとき、
＞α(n)=φ_(β(n))(φ_(β)(γ')+1)とします。

ここのa(n)がこの形に展開される理屈が分かりませんでした。
値をうまく置き換えてやればφ_β(γ)=αに持っていけるのでしょうか。

どうにもφ_nという式が顔を出してきます。この子ってば
どうやって飛ばせばいいですか。
α=φ_ω(1)=ε_1なのかなーと思ったり。

βへの収束列がβ(n)の場合の具体例の様子を見てみました。
ここではβ=ωとおいて　β(n)=n,γ'=0とする。　このとき、

α=φ_ω(1)
α(n)=φ_n(φ_ω(0)+1)
α(0)=φ_0(2)=0^2=1

ここで定義より　α=φ_ω(1)=ε_1　なお、このαの収束列は、

1,ε_0,ω^(ε_0+1),ω^ω^(ε_0+1),ω^ω^ω^(ε_0+1),…と続き、

α(0)=1
α(1)=ε_0　そして最終的にnが十分大きいとき
α(n)=(ω↑↑(n-2))^(ε_0+1)となる。

これがα=(ω↑↑ω)^(ε_0+1)=ε_1　の収束列である。

話を　α(n)=φ_n(φ_ω(0)+1)　に戻すと、

φ_ω(0) = 「すべての ω'< ω に対し φ_ω'(δ)=δ となる δ」 のうち
0番目のもの。　ω'=0　とおくと(ωより小さい順序数は自然数しかない)
φ_0(δ)=ω^δ=δ　が得られ、

定義より　φ_ω(0)=ε_0　から　α(n)=φ_n(ε_0+1)　以上より

φ_n(ε_0+1)=(ω↑↑(n-2))^(ε_0+1)　(n<2)　　　謎のオチ。

思いつきで喋っていますが。
文京区シビックセンターの良さげな部屋を借りるツテができたので
2月あたりに近隣の方はゼミごっこしませんか？
メンツが集まらない場合は、素人衆に巨大数をオルグする
イベントに変更となります。いかがでしょう。
僕が暇すぎるのかもしれません。

うちの近くだｗ

>>178
φ_ω(1)=ε_1というのは、もしかしてωを1に置き換えてますか？
Hardy functionと違ってφの添え字のωは1に置き換えられません。
φ_ω(0)というのは、φ_0(0), φ_1(0), φ_2(0), φ_3(0), …という収束列の収束先で、
φ_ω(1)というのは、φ_0(φ_ω(0)+1), φ_1(φ_ω(0)+1), φ_2(φ_ω(0)+1), …の収束先です。

>>181
えーっと…

φ_ω(1)=「すべての ω'< ω に対し φ_ω'(δ)=δ となる δ」 のうち
1番目のもの　…ここですな。
もろに文脈が混線していたようです。

さて、
α=φ_ω(1)　のとき
α(n)=φ_n(φ_ω+1)　などと性懲りもなくやってますが、
φ_β(γ)そのものが列の収束先そのものとは、全く気付きませんでした。
いやはや。

数学板オフ？
都内ならkingも呼ぼうぜ。

巨大数に関連した催しとして僕個人が突発的に企画しました。
いっぺんホワイトボード使ってワイワイやってみたかったのです。
情報や理解も共有することができるかもしれないですし。
往年の功労者諸氏はもう見てないかな…
あと、民間人に巨大数ロマンを植え付けるという企みもあります。
30人くらい入れる部屋とか用意できますが、そんなには来ないでしょう。
2/10を候補日としています。

Cantor normal formの和訳みたいなことをしてみました。そしたら
「集合論入門　無限への誘い」の169,170ページにも「カントールの標準形」
の解説がありました。読み比べてみたところ、それぞれ少し異なる箇所が
あったりしたので適当にまぜて体裁を整えました。
やばかったら指摘してください。たぶん本読んだ方が早いですが。


0でない任意の順序数αは以下のような式に一意に展開することができる。

α=((ω^(β_1))・c_1)+((ω^(β_2))・c_2)+…+((ω^(β_k))・c_k)　　　[kは自然数]

c_1,c_2,…,c_k　は正の整数
β_1＞β_2＞…＞β_k　はそれぞれ順序数　(β_k=0 でも可)

上式ではωを用いているが、これは「ωを底とした」場合である。
底には2以上の順序数を用いてよい。
このように展開された式を、αのCantor normal formと呼ぶ。

任意なの？
非可算順序数でも大丈夫なんだ。

任意でよかったはず

talk:>>183 何やってんだよ？

>>186

任意でおｋです。

英語版Wikipediaに、Γ_0よりずっと大きい順序数を定義する方法がありました。
それを和訳すると下のようになります。
　ψ(α)は、0とΩ(最小の非可算順序数)から始めて、それ以前に作られた順序数に対し
　加法、Veblen関数、ψを繰り返し適用しても作ることのできない最小の順序数である。
　ただし、ψはαより小さい順序数に対してのみ適用する。
定義には非可算順序数を用いていますが、定義される順序数は可算です。
これだけだとよく分からないし、具体例はほとんどなかったので、自分なりに解釈してみました。
もしかしたら、間違っているところがあるかもしれませんが。

まず、ψ(0)を考えます。この時点ではまだψは使えないので、加法とVeblen関数だけを使います。
0に対して加法とVeblen関数を使うと、Γ_0未満の順序数をすべて作り出すことができます。
Ωから作った順序数はどれも非加算なので、Γ_0を作り出すことはできません。
なので、ψ(0)=Γ_0ということになります。
次に、ψ(1)を考えます。これは、0とψ(0)とΩに対して加法とVeblen関数を使っても作れない
最小の順序数ですが、これはΓ_1です。同様にして、ψ(α)=Γ_α(ただし、α≦ψ(Ω))となります。

この方法を繰り返していくと、Γ_Γ_Γ_…_0の収束先として定義される順序数
(>>132,>>136の表記を用いるとφ([2,1],[1,1])と書ける)よりも小さな数はすべて作ることができますが、
φ([2,1],[1,1])は作ることができません。そこで、初めてψ(Ω)を考えます。
ψ(Ω)は、0とΩに加法、Veblen関数、ψを適用しても作ることのできない最小の順序数です。
(ただしΩにはψを適用しない)　つまり、ψ(Ω)=φ([2,1],[1,1])です。

ψ(ψ(Ω))を考えると、ψ(Ω)=φ([2,1],[1,1])より小さい順序数に
加法、Veblen関数、ψを適用しても作ることのできない最小の順序数なので、
ψ(ψ(Ω))=ψ(Ω)=φ([2,1],[1,1])となります。
ψ(Ω)≦α≦Ωとしてψ(α)を考えると、ψ(Ω)を使うことはできないので、ψ(α)=ψ(Ω)となります。
なので、次はψ(Ω+1)を考えればいいです。

あとは結果だけ書きますが、>>132,>>136の表記とψを用いた表記を比較すると、
ψ(Ω^Ω^α)=φ([α,1]) (α≧ω)となるようなので、
>>132,>>136の表記ではψ(Ω^Ω^Ω)未満の順序数しか表せないようです。
6-708で出てきたHoward ordinalというのはψ(ε_(Ω+1))だそうです。
ε_(Ω+1)はおそらくΩ^Ω^Ω^…^Ωの収束先です。

Ω^Ω^ΩをVeblen関数で表すには、Ω=ω^Ωという性質を使って
Ω^Ω^Ω=(ω^Ω)^Ω^Ω=ω^(Ω*Ω^Ω)=ω^Ω^Ω=ω^(ω^Ω)^Ω
=ω^ω^(Ω*Ω)=ω^ω^(ω^Ω*ω^Ω)=ω^ω^ω^(Ω+Ω)として、
Ω^Ω^Ω=φ_0(φ_0(φ_0(Ω+Ω)))とすればいいと思います。
非可算順序数を可算順序数と同じように扱っていいのかは分かりませんが。

(^ω^)よくわからないお

本当に分かろうとする気があるのかと、
ただ(^ω^)を貼り付けたいだけちゃうんかと。

ψで表された順序数への収束列は、おそらく以下のように定まるはずです。
　α=ψ(0)のとき、α_0=φ_0(0), α_(n+1)=φ_(α_n)(0)
　α=ψ(β+1)のとき、α_0=ψ(β)+1, α_(n+1)=φ_(α_n)(0)
　α=ψ(β)(βは収束列の定義された順序数)のとき、α_n=ψ(β_n)
　α=ψ(β)(βは収束列の定義されていない非可算順序数)のときは、
　以下の手順で収束列を定める。
　　まず、βに注目する。
　　注目する順序数がΩになるまで、以下の手順を繰り返す。
　　　注目する順序数が和のときは、一番右の項に注目する。
　　　注目する順序数がφ_γ(δ)の形のときは、以下のようにする。
　　　　δ=0のときは、γに注目する。
　　　　δ=δ'+1のときは、δをφ_γ(δ')+1に置き換えてからγに注目する。
　　　　その他のときは、δに注目する。
　　ψ(β)の、注目するΩをxで置き換えた関数をf(x)とする。(f(x)は順序数の関数)
　　α_0=0, α_(n+1)=f(α_n)とする。
最後の手順を、具体例でやってみます。(かなり複雑な例ですが)
　ψ(φ_(φ_(φ_Ω(Ω+Ω))(Ω+2))(0))でやってみると、
　まずはφ_(φ_(φ_Ω(Ω+Ω))(Ω+2))(0)に注目します。
　( )の中が0なので、添え字のφ_(φ_Ω(Ω+Ω))(Ω+2)に注目します。
　( )の中が+1の形なので、Ω+2をφ_(φ_Ω(Ω+Ω))(Ω+1)+1に置き換えて、
　添え字のφ_Ω(Ω+Ω)に注目します。
　今度は( )の中が0でも+1の形でもないので、Ω+Ωに注目します。
　Ω+Ωは和なので、右のΩに注目します。
　注目したΩをxに変えると、
　f(x)=ψ(φ_(φ_(φ_Ω(Ω+x))(φ_(φ_Ω(Ω+Ω))(Ω+1)+1))(0))
　となります。　この関数を入れ子にしたものが収束列となります。
この収束列の定義でHardy functionも使ってF[ψ(Γ_(Ω+1))]という関数を作ると、
ものすごく大きな自然数の関数となるはずです。
ただし、Γ_(Ω+1)の収束列はα_0=Ω+1, α_(n+1)=φ_(α_n)(0)です。

結局のところ、巨大な非可算順序数を作り、非可算順序数から巨大な可算順序数の関数を作り、
可算順序数の関数から巨大な可算順序数を作り、可算順序数から巨大な自然数の関数を作り、
自然数の関数から巨大な数を作るということになります。
Ωを可算順序数の変数で置き換えるのと、ωを自然数の変数で置き換えるのには共通点も見られます。

今やっていることがよく分からないという気持ちも分かります。
具体的に計算しようにも巨大すぎて、現実には計算できないような数を扱っているし、
主題は数→自然数の関数→順序数→可算順序数の関数と、どんどん普通の数から離れてきているので。
ただ、作られていく数はどんどん巨大になってきています。

一つ残念なのは、このスレの住人がこれまでにないような巨大な数を作り出したと思っても、
いつもそれを上回る巨大な数を作り出す方法が既に数学界に存在しているということです。
上で述べた関数も、Hardy functionと英語版Wikipediaのψ表記を組み合わせただけなのに、
このスレで作られた関数の中ではふぃっしゅ数ver.4を除くどの関数よりも大きいわけです。
(ふぃっしゅ数ver.4はBBを用いて作られた、定義可能だが計算不能な数なので別格ですが)

それでも、巨大な数の作り方を紹介していくというだけで十分意味のあることだと思いますが。

>>179 >>184
ゼミは本当にやるのかな？はたして、このスレの
住人は何人くらい集まるか？

素人衆向けの企画ならば、素人衆として参加します。
実際に素人衆だし。

>>197
部屋はすでに取ってあります。2/10午後、文京シビックセンター会議室です。
初心者と熟練者の議論のギャップをどう埋められるか、という。
とりあえずその日程オッケーみたいな方は、ここで点呼してみて下さい。
5人も集まれば、十分に時間が潰せると思います。たぶん。

WikipediaにもHoward ordinalについて書かれていますね。
英語ならHoward ordinalの定義について書いてある論文は結構見つかるのですが、
分かりやすかったものは、Veblen関数の応用で、

φ_α[Ω](β):=φ_α[γ](0)=γとなるγのうちβ番目のもの

とします。例えば、φ_Ω(0)=Γ_0、φ_(Ω+1)(0)=Γ_Γ_Γ_……となります。
以降はCNFと同様に、

Ω^α_0*β_0+Ω^α_1*β_1+Ω^α_2*β_2+……
（ただしα_0>α_1>α_2>……, Ω>β_i）

とすれば、φ_α(β)の有限和でHoward ordinalより小さいすべての順序数を表記できます。

また、１変数にすることもできますね。

A(α):=ω^α（Ω>α）
A(α[Ω]+β):=A(α[γ])=γとなるγのうちβ番目のもの

例えば、
A(Ω)=ε_0
A(Ω*α+β)=φ_α(β)
A(Ω^2)=Γ_0　です。

もちろんA(ε_(Ω+1))とかもできますがさらに上の基数を使って、

B(α):=Ω^α
B(α[ω_2]+β):=B(α[γ])=γとなるγのうちβ番目のもの
とすれば、A( B(ω_2) ) = A( ε_(Ω+1) ), A( B((ω_2)^2) ) = A( Γ_(Ω+1) )
となってHoward ordinalよりも大きい順序数を作ることができます。
しかし、この方法だとA(Ω),A(B(ω_2)),A(B(C(ω_3))),A(B(C(D(ω_4)))),………
という列の極限順序数が限界で、以降のうまい定義がなかなか難しいのですが・・・

順序数の表記についてのサイト↓（英語）
http://web.mit.edu/dmytro/www/other/OrdinalNotation.htm

英語版Wikipediaには、ψの拡張法の方針も載っていたので、それを定義してみました。
　ψ_α(β)は、0に対して加法、Veblen関数、ψを繰り返し適用しても
　作ることのできない、濃度がω_α(α番目の無限基数)の最小の順序数である。
　ただし、ψの添字として用いる順序数を除いては、ψはβより小さい順序数にのみ適用する。
最後の行では、例えばψ_[ψ_0(1)](0)=ψ_[ψ_0(1)](1)＜ψ_[ψ_0(1)](2)のような
不自然なことを起こさないために、添字ではψを自由に使えるようにしてあります。

濃度に関しては、次の性質だけ理解しておけば十分だと思います。
　ω以上の順序数には、濃度として一つの無限基数が対応する。
　可算順序数の濃度は、ω(=ω_0)である。
　α＜βならば、濃度ω_αの順序数＜濃度ω_βの順序数である。
　濃度ω_α以下の順序数の収束列は、濃度ω_α以下の順序数に収束する。
最後の行は、「以下」であって「未満」ではありません。
例えば、ω_nはω_ω未満の順序数の収束列ですが、ω_ωに収束します。

添字付きψで定義される最大の非可算順序数はω_ω_…_0の極限です。
この順序数を仮にΨと書くことにすると、
添字付きψで定義される最大の可算順序数は、ψ_0(Ψ)となります。

収束列の定義は、以下のようになるはずです。
　α=ψ_0(0)のとき、α_0=φ_0(0), α_(n+1)=φ_(α_n)(0)
　α=ψ_β(0)のとき、α=ω_βであり、
　　βに収束列があるときはα_n=ω_(β_n)となる。
　α=ψ_β(γ+1)のとき、α_0=ψ_β(γ)+1, α_(n+1)=φ_(α_n)(0)
　α=ψ_β(γ)(γは収束列の定義された順序数)のとき、α_n=ψ_β(γ_n)
　α=ψ_β(γ)(γは収束列の定義されていない非可算順序数)のときは、
　以下の手順で収束列を定める。
　　まず、γに注目する。
　　注目する順序数がψ_[δ+1](0)の形になるまで、以下の手順を繰り返す。
　　　注目する順序数が和のときは、一番右の項に注目する。
　　　注目する順序数がφ_ε(ζ)の形のときは、以下のようにする。
　　　　ζ=0のときは、εに注目する。
　　　　ζ=ζ'+1のときは、ζをφ_ε(ζ')+1に置き換えてからεに注目する。
　　　　その他のときは、ζに注目する。
　　　注目する順序数がψ_ε(0)の形のときは、εに注目する。
　　γの、注目するψ_[δ+1](0)をxで置き換えた関数をf(x)とする。
　　α'_0=0, α'_(n+1)=ψ_δ(f(α'_n))とし、
　　収束列はα_0=0, α_(n+1)=ψ_β(f(α'_n))とする。
　　（つまり、最後だけはψ_βを適用し、それ以外はψ_δを適用する）
　Ψ_0=0, Ψ_(n+1)=Ψ_[Ψ_n](0)

Hardy functionや、上記の順序数の計算のできるプログラムをRubyで作ってみました。
Rubyはttp://arton.hp.infoseek.co.jp/indexj.htmlからインストールしてください。
ttp://www.uploda.net/cgi/uploader4/index.php?file_id=0000009755.lzh
解凍するとLarge_number.rbというファイルがあるので、
これをメモ帳などで開くと初めの方に使い方が書いてあります。

>>203
ＧＪ！ありがたく使わせていただきます。

この前のプログラムはまだバグが残っていたので、修正しました。
ttp://www.uploda.net/cgi/uploader4/index.php?file_id=0000009781.lzh

プログラムは細かくみると、正確に計算してないところもあります。
たとえば、ω^φ_1(0)=ω^ε_0=ε_0=φ_1(0)ですが、
F[ω^φ_1(0)](2)とF[φ_1(0)](2)は違う結果になります。
また、>>190の定義からすればψ(ψ(Ω+2))=ψ(Ω)＜ψ(Ω+1)ですが、
F[ψ(ψ(Ω+2))](2)＞F[ψ(Ω+1)](2)となってしまうはずです。
ただ、普通に使う分には問題はないと思います。

>206
>>130-131

206も、130-131も、プログラムを書いたのも、全部私なので、
>>130-131みたいに収束列の異なる順序数は別物という見方をすれば
前者は問題ないのは分かってます。
後者に関しては、>>190での定義によるψと、
>>195の収束列から定義されるψが全く同じではないのが原因です。

数学的に厳密に言うのならば、Hardy functionに使っているものは
極限順序数ではなく、「収束列」です。ここでいう「収束列」は、
”自然数か「収束列」の列”として再帰的に定義できます。
ただ、「収束列」は列の収束先の極限順序数と対応づけることができ、
順序数の大小とHardy functionの増加度の大小には関連性があるので、
極限順序数と「収束列」を普段は同一視しているわけです。
でも、極限順序数と「収束列」は違うものであるため、>>206の前者のような問題が生じます。

>>131で「極限順序数と収束列は一対一に対応する」と言ってしまったのは不正確で、
極限順序数と「収束列」は一対多に対応します。
「収束列」と一対一に対応する（正確には「一対一対応させている」）のは、「極限順序数の表記」です。
>>205のプログラムが計算しているのは順序数ではなく、「収束列」です。
>>206で「プログラムが正確に計算してない」といったのも不正確ですね。
不正確だったのは定義の方であって、プログラムの計算が不正確なわけではありません。

999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999

この極めて小さい数に何か意味があるのだろうか。。。。。

=(ω^Ω)^Ω^Ω=ω^(Ω*Ω^Ω)=(^o^)=ω^(ω^Ω)^Ω
=ω（=´ω`=）^ω^(Ω*Ω)=(^ω^)(^ω^)(^ω^)(o^Ω^o)=ω^ω^ω^ ^^ ^^

073

いよいよ明日ですね

本当にやるの

えーと、グレートに人が集まらないので次回に仕切り直そうかと思ってます。
ちゃんと準備して。

人の脳を読む能力を悪用する奴を潰せ。

ちょいと質問。
「グラハム数」のグラハム博士って、電話発明したグラハム・ベルと親戚？
ゼミ後に検索してみたら「秋山仁」やら「ベル研究所」がヒットしますが…

ロナルド L. グレアムとアレクサンダー・グレアム・ベルか。
別にしんせきじゃねえんじゃね。

Ronald Grahamはピーター・フランクルの友人で
AMSの会長をやってたこともある人。
秋山仁と日本語の離散数学の入門書も出してるね。

時代が全然違うからあまり「親戚」とは言わないんじゃないかなあ。
Ronald Lewis Graham (born October 31, 1935)
Alexander Graham Bell ( March 3, 1847 ? August 2, 1922 )

http://en.wikipedia.org/wiki/Ronald_Graham
http://en.wikipedia.org/wiki/Alexander_Graham_Bell
http://ja.wikipedia.org/wiki/%E3%82%A2%E3%83%AC%E3%82%AF%E3%82%B5%E3%83%B3%E3%83%80%E3%83%BC%E3%83%BB%E3%82%B0%E3%83%A9%E3%83%8F%E3%83%A0%E3%83%BB%E3%83%99%E3%83%AB

たぶん親戚関係は無いんじゃないの。日本の田中さんとかと同じで。

ωやΩの固まりからどうやって自然数にするのかが気になるな....

sage忘れスマソ

オフと聞いてやってきました

保守しておく

age

age

ひさしぶりにのぞいてみたが、
大して進展はないのかな？

今のところチャンピオンは前スレの >>863 か。

これかな？File not foundになるのが惜しいところ。

863 ：通りすがり：2006/08/29(火) 21:34:51
>>440-441 をちゃんと書いてみた。
チューリングマシンのままじゃ扱いにくいので、
今のコンピューター風命令にした。
ついでに拡張も。

http://free.gikoneko.net/up/source/up124719.txt

ついでに440-441もコピー

440 ：通りすがり：2006/03/09(木) 18:27:05
●STEP0
比較的単純なマシンモデル（チューリングマシン）を定義することで、
どのような帰納的定義の関数よりも早く増大する関数、ビジービーバー関数が定義出来た。
ビジービーバー関数は「どのような帰納的定義の関数よりも早く増大する関数」の中ではほとんどＭＩＮの関数である。
BBに帰納的拡張をしていくことである程度大きくすることは可能。、
（BB^n(2)やBBのふぃっしゅ数的拡張など）

●STEP1
チューリングマシンにビジービーバーの値を返す動作を追加したマシンを考えてみる。
厳密にはたとえば、
各ステートの動作定義に１ビット加え、このビットが立っていたら
BB(テープ上のヘッド位置から右に続く１の数)個の１をヘッドの右側に書き込むという動作で良い。
このマシンｎステートでセット可能な１の数の最大をBB2(n)とすると、
この関数はビジービーバー関数に通常の多重帰納的定義を用いて拡張したどんな関数よりも早く増加する。
（BBのふぃっしゅ数的拡張もBB2に及ばない）

一般に、
『チューリングマシン＋関数f』のマシンｎステートで
セット可能な１の数の最大をBB｢f｣(n)とする。
BB｢f｣ は、fに通常の多重帰納的定義を用いて拡張したどんな関数よりも早く増加する。
BB｢恒等変換｣ = ビジービーバーであり、
BB｢ビジービーバー｣ が上の BB2 である。

BB｢f｣の｢｣の中に関数を入れることで新たな関数ができ、
帰納的定義の関数のように帰納的にBB｢f｣の定義が可能である。

441 ：１３２人目の素数さん：2006/03/09(木) 18:28:15
●STEP2
STEP1の方法でマシンの帰納的定義を行っていけば大きい関数が作成できるが、
この方法にも限界がある。
この限界を超える為にはチューリングマシンに以下のような機能追加が必要である。

１．自然数から自然数への関数をテープに読み書きできる（可算無限のデータ量）
２．テープに関数の初期値（恒等関数で良い）をセット出来る
３．関数fからBB｢f｣をつくることが出来る
４．関数の値を返せる
といった感じであろうか。
（厳密な定義は他の人に任せる）

このようなマシンｎステートで表現できる最大の数をCC(n)とする。
これはいわば「STEP1の帰納的拡張をｎ文字以内で一番効率よく行った場合の数」
のようなものであり、CC(n)はBB｢｣のどんな帰納的拡張よりも早く増大する。

●STEP3
さらなる拡張はやはりマシン自体を定義できるようなマシンということになるだろう。
矛盾がおこらないような定義で最良のものはどんな感じになるのかな？

停止問題を解くことが出来るマシンを考えればずっと大きな数を作ることが出来る。

あるチューリング完全マシンをMachine[0],
Macihne[0]のn命令のプログラムで表現可能な最大の数をM[0](n)とすると、
M[0](n) ≒ BB(n)

Machine[0] の停止問題を解く命令をhalt[1],
Machine[0] に halt[1] の命令を追加したマシンを Machine[1],
Macihne[1]のn命令のプログラムで表現可能な最大の数をM[1](n)とすると、
M[1](n) は 前スレ >>863 の mm(n) を大きく超える。

Machine[a]のｎ命令のプログラムで表現可能な最大の数をM[a](n)
Machine[a] の停止問題を解く命令をhalt[a+1]
Machine[a] に halt[a+1] の命令を追加したマシンを M[a+1]
としてM[a]を定義することが出来る。

halt[a] を 「b<a となるすべてのマシン Machine[b] の停止問題を解く命令」としても同じであり、
この定義にすると、a を順序集合に拡張できるようになる。
M[ω](n), M[ω^ω](n), M[Γ_0](n) などが定義できる。

>>230
> 前スレ >>863 の mm(n) を大きく超える

前スレ >>863 のプログラムが見えないので、どこかにアップしてもらえますか。

>>231
http://2ch-library.com/uploader/src/2ch6734.txt

>>230 は検証せずにイメージで書いちゃったけど、
> M[1](n) は 前スレ >>863 の mm(n) を大きく超える。
これは嘘でした。

>>232
サンクス。念のため、魚拓で保存しておきました。
http://symy.jp/?eblK

かなり改善された模様

それって計算可能なの？

チューリングマシンでは計算不可能なんじゃね

Ackerman関数より急に増加するような関数は
たいてい計算不可能なんじゃないかな

何言ってるんだ俺ｗ

( ^ω^)

数学は加減乗除くらいしか判らないんですが、物や人の歴史には非常に強い
興味があるので、このスレは10文字で云々って頃から見てました
プロジェクトX風ナレーションで、マジ泣きしたこともありました

で、ふと思ったんですが、現在20文字部門最強の
＞f(n):=nに階乗をn回
＞f^9!(9)
と、
グラハム数をグラハム数!回階乗
では、どちらが大きいんでしょうか？
表記のルールに反するので対象外だとは思いますが、私の知識だと「f(n)」
ってのが既に何なのか判らないので、比較ができません
どなたか教えて頂けませんでしょうか？
また、「グラハム数」の表記が認められた場合、どのような表記が最大になる
のでしょうか？

２０文字部門最強よりグラハム数の方が大きいんじゃないか？
グラハム数！回階乗なんかしなくても。

>>241
ありがとうございます
意外と小さいんですね
って、それだけグラハム数が大きいってことで、そんなのもミクロの世界に追いやる
ふぃっしゅ数が偉大だってことなんでしょうけど

数に偉大も何も無いと思うけどなー。
あ、でも数を擬人化すればこそこんなバトル風になったのか。

フィッシュ数たん( ;´Д`)ﾊｧﾊｧ






こうですか？　わかりません＞＜

>>243
です
基本的な数学の概念自体判ってないので、自分なりに理解する為に
脳内で物語とかを展開しながらROMってます
何スレか前、RPG風にスレの流れを書きましたが、あんな感じです

ふぃっしゅ数は打たれても打たれても立ち上がってくる、ジャンプ系の
主人公って感じでしょうかね
戦隊組んだら、ふぃっしゅ数は間違いなく赤だと思います

ふぃっしゅ数なんて力技で作った数なんかどうでも良い。

いくら作ってもミクロなところを出られないてのが凄いな。
探索は限りないんだろうか。なんかの構造的なシフトでもどっかにあるんだろうか。

誰か２０文字最強をチェーンとかタワーで評価して頂けないでしょうか。

9999999999→999999999
か
9999→9999→9999→99999
か
999→999→999→999→9999
か
99→99→99→99→99→99→99
か
9→9→9→9→9→9→9→9→9→99
のどれかじゃないかと思うんですけど、>>240なので比較できません(;´Д`)

→の定義が無いと自然数を定義したとは言えない

>249
一番上以外は全部グラハム数より遥かにデカイ
当然のごとく一番下が最大だろう

>>248
文字の規定はどうするんだ？
ある記号に意味をいくらこめても良いんじゃ意味ないし。

チェーン表記の矢印を定義するには、タワー表記の矢印も定義しなきゃ
ならないんですね
数字2つなら「a→b=a^b」でいいけど、3つ以上になると定義の説明だけで
20文字超えそう

>>248 の意味をだれも理解してないところが数学板クオリティー

>>248
９↑↑↑(９！) ＜ 「２０文字最強」 ＜ ９↑↑↑(９！＋２) ＜ ２↑↑↑↑３ ＝ ２→３→４

>>254
証明付けてやったろうかと思ったら思いのほかめんどかったし、
その間に別のレスがついたし。
まぁこの程度の比較してるだけなら証明なんて不要なんだろうと思ったし。

http://www.geocities.co.jp/Technopolis/9946/game.html

20文字部門は f^9! と括弧なし
30文字部門は f^(99!) と括弧あり
な理由がわからん。

F[ψ(Γ_(Ω+1))](グラハム数) < BB(120)

>>254
理解してるだろう・・・。

>>257
ただ単にn文字で大きな数では曖昧なため、
C++言語を使ったルールを考えてみました。

C++言語のnトークン(n語)で大きな数をつくるというものです。
　　int main();
がどれだけ大きな整数を返すか競います。

----------ルール-----------
int 型は無限長符号付整数とします。
数値（即値）は十進表記のみであらわしますが、
数値だけは例外として桁数をトークン数に数えます。
（コメントや空白はカウントしません）

以下のような、処理系に依存するコードはNGとします。
　引数の評価順に依存するコード、
　不定値参照、
　sizeof 演算子、
　ポインター <=> 0以外の整数値 のキャスト
　など

プリプロセッサの使用、ライブラリの使用は不可

// 10 word
int main(){
　return 99;
}

// 20 word
int main(){
　return 9<<(9<<(9<<99));
}

// 30 word
int main(){
　int a = 99, b = a<<a;
　while (b--)
　　a <<= a;
　　return a;
}

// 40 word
int main(){
　int a = 9<<9, b, c = a;
　while (b = a, c--)
　　while (b--)
　　　a <<= a;
　return a;
}

// 50 word
int func(int a, int b){
　return
　　a ?
　　　b ? func( a-1, func(a, --b) )
　　　　: a
　　　: ++b;
}
int main(){
　return func(9,9);
}

// 返す値: アッカーマン関数
// 定義域: a >= 0, b >= 0
// サイズ: 42
int Ackermann(int a, int b){
　return
　　a ?
　　　b ? Ackermann( a-1, Ackermann(a, --b) )
　　　 : Ackermann(--a, 1)
　　 : ++b;
}

// 返す値: クヌースの矢印表記 a ^^...^^ b (^ がc個)
// 定義域: a >= 1, b >= 0, c >= 0
// サイズ: 44
int Knuth(int a, int b, int c){
　return
　　c ?
　　　b ? Knuth( a, Knuth(a, --b, c), c-1 )
　　　 : 1
　　 : a * b;
}

// 返す値: コンウェイのチェーン表記 p[0] → p[1] → ... → p[s-1]
// 定義域: s >= 1, p[i] >= 1
int Conway(int s, int *p){
　int i = s, int *q = new int[s];
　while (i--)
　　q[i] = p[i];

　if (s == 1)
　　return p[0];

　if (p[s-1] == 1)
　　return Conway(s-1, p);

　if (s == 2){
　　q[1] --;
　　return b[0] * Conway(s, q);
　}

　if (p[s-2] == 1)
　　return Conway(s-2, p);

　q[s-2] --;
　q[s-2] = Conway(s, q);
　q[s-1] --;
　return Conway(s, q);
}

H[Γ_0](99) のソース

http://2ch-library.com/uploader/src/2ch6803.cpp

>>190-203 を参考にして、
>>205 に定義されているΨ(ψの極限)を使って、
hardy[ψ(0, Ψ)](99) を返す関数を作ってみました。

http://2ch-library.com/uploader/src/2ch6886.cpp

>>266 のように、ある言語を用いて大きな可算順序数を作ることを考える。
n文字（またはn単語、nトークンなど） で表せる最大の可算順序数を
o(n) とした場合、この極限 lim o は可算なのだろうか？

可算だとすると、
帰納的定義では到達できないほど大きな可算順序数が存在することになる。

非可算（つまりΩ）になるとすると、
可算順序数の列で、極限が非加算になるものが存在することになる。

ω_1のcofinalityはω_1だから、可算順序数の可算列ではω_1にはならないんじゃないか？

cofinalityというのは知りませんが、
> 可算順序数の可算列ではω_1にはならないんじゃないか？
ということは、

帰納的定義では到達できない最小の順序数を☆_0とし、
☆_0と帰納的定義では到達できない最小の順序数を☆_1とし、
....
☆_n の極限を☆_ω とし、
....
☆_☆_...._☆_☆_0 を ★_0 とし、
....

とか定義できるのかな？

cofinalityってのは共終数と言って、順序数論ではかなり
基本的な概念だから、順序数を使って急増加函数を作りたいなら
勉強したほうが良いよ。無理にとは言わないけどね。

n文字を用いて或る数を表す、とかいうときの文字数は
Peano算術なりZFCなりの論理式の文字数と考えれば良いだろう。
μxP(x)と表したときのPでも良いだろうし。
Pに量化記号が無制限に入っていいことにすると、
急増化函数の存在がZFCから独立、
なんてことが起こるから基礎論に詳しくないとどう考えていいか分からなくなるけど。

>>270
わざわざどうも。
私は基礎論も順序数論も集合論も詳しくないので、先は長そう。

帰納的定義によりたどり着ける順序数は、
言語によらず同じで、
☆_0 も１個に定まると楽観的には思いますが、
いかがでしょうか。

H[☆_0](n) は計算不可能（アルゴリズム存在せず）なので、
結局BB(n)と実質同じになります。

●このスレで出た最大
順序数、基数、濃度: Ψ
可算順序数: ★_0
帰納的定義の可算順序数: ψ(Ψ)
関数: >>230
帰納的定義の関数: H[ψ(Ψ)](n)

>>266
保存しておきました。
http://symy.jp/?C1vg

recursiveでない最小の順序数はω_1^CKという（Church-Kｌeene順序数）

>>273
もう既に名前がついてるんですか。

>>202では、
ψ_α(0) を、濃度がω_αである最小の順序数としていますが、
ψ_α(0) = ☆_α としてもまったく同じように各順序数の収束列を定義でき、
>>203 や >>266 のプログラムもまったくかわらず、
H[ψ(Ψ)](n) の値もまったく同一になりますね。
（この場合、Ψ=★_0）
さらにψ_α(0)を小さく定義することもできそうです。
（つまり帰納的定義の範囲内）

こう考えると、
はじめは H[ψ(Ψ)](n) の定義には巨大な基数が現れるので、
H[Γ_0](n) に比べて革命的に大きくなっているように見えたんですが、
だんだんと普通の拡張に見えてきました。
プログラムも２倍程度に増えただけですし。

あげ

関数の大小の比べ方なんですが、以下のようなことを考えてみました。

任意の自然数cに対しある数nが存在しn<xならばf^c(x)<g(x)が成り立つならばgはfより本質的に大きい。

というアイディアはどうでしょうか。既出かもしれませんが。

>>276
g = f^x(x) と定義すれば、gはfよりも本質的に大きくなるね。
通常の関数であれば十分に本質的に大きい、と言えるだろうけど、
たとえば>>230のような関数に対してこのような拡張をしたところで、
本質的に大きいとは言えないかも。

http://web.mit.edu/dmytro/www/other/OrdinalNotation.htm

ここにある「C」は、「An Ordinal Notation」の段階で
>>202 の添字つきψと同じ順序数まで表せる模様。
さらに、
「A Stronger Ordinal Notation」
「Second Order Arithmetic」
「Beyond Second Order Arithmetic」
と続くので、相当巨大な順序数が作れそう。

>>277
２７６ですが、どうもこの方法は原始帰納関数？では上手く機能すると思うのですが、
それ以上となると駄目なような気がなんとなくしてきました。

>>276
計算可能な関数に関しては、
Hardy Function を用いて、F[順序数](n) という形に近似して順序数の大小で比較。

Hardy Function を本質的に超える関数が出てくるまでは、
これで大小比較が可能。
（順序数が本質的に大きいかどうかという問題になる）

---例---
Knuthの上矢印 3(↑^n)3 ≒ F[ω](n)
n個のnからなるConwayのチェーン ≒ F[ω^2](n)
↑n (3,3,3) ≒ F[ω^3](n)
Ak(n, 3) = ≒ F[ω](n)
Ak を多変数に拡張、Ak(n個のn) ≒ F[ω^ω](n)
Ak を２重リストに拡張、Ak([n個のn], [n]) ≒ F[ω^ω^ω](n)
Ak を多重リストに拡張、Ak(n重リスト) ≒ F[ε_0](n)

ちなみに、g = f^x(x) とするのは、F[順序数](n) の順序数に1を加えるのと同じ効果。

----
計算不可能なものも含めた場合には、
ある程度小さなものは、
>>230 の形に近似して順序数の大小で比較すれば良いが、
順序数をマシンで生成させ、これを引数とするHALT[順序数] 命令にすると、
M[順序数](n) よりも大きくなるため、順序数での比較は不可になる。

>>260 のルールで作ってみました。
http://up.spawn.jp/file/up29497.txt.html

F[ω^3] までゆっくりで、一気に F[φ_ω(0)] まで飛んでます。
F[ω^4], F[ω^ω], F[ε_0] なども作ってみたけど、
F[φ_ω(0)] より大きくなってしまいました。

順序数を使う２個は >>278 の C を参考にしてます。
「An Ordinal Notation」より手前の段階のを多変数にしてます。
veblen関数を普通に多変数にしたものよりは効率がよさそうです。
（+ の定義まで含まれているのと、収束がちょっと簡単）

いずれは
「An Ordinal Notation」や「Beyond Second Order Arithmetic」、
「An Ordinal Notation」から「Beyond Second Order Arithmetic」を順序数回繰り返したもの
など、より大きなものを作る予定。

あと、>>280 にある、
アッカーマンの拡張で F[ε_0] やその先まで到達する方法をまとめました。
http://up.spawn.jp/file/up29500.txt.html

----BB以上の関数----
M[順序数](n) の関数を作るには、
>>233 の基本命令に
test ** という命令を加えればよい。

これは、ラベル ** へジャンプした場合に halt で停止する場合はポインタ位置を1にセット、
無限ループする場合はポインタ位置に0をセットする命令。

この命令は引数として順序数を取る。
ジャンプ先に、引数以上の test ** 命令が出現する場合には停止問題は解決できない為、
ジャンプ先で、halt より前に、引数以上の test ** 命令が出現する場合は halt と同じ動作をする。

引数の順序数の与え方は、
たとえばM[ω](n)を定義するマシンの場合には、
ポインタ位置から１が続く個数を数え、これを引数nとする。

M[C(a, b, c) の極限](n) を定義するマシンの場合は、 ...(Cは>>278のもの)
順序数を 0 , C ( ) の５個の文字で表し、
0 には 1 を、
, には 11 を、
C( には 111 を、
) には 1111 を、
割り振り、
文字の境目を 0 としてエンコードしたものを引数とすればよい。
たとえば、ポインタ位置から 111 0 1 0 11 0 1 0 11 0 1 0 1111 となっている場合は
引数は C(0,0,0) と解釈する。
※ C(a, b, c) は0とCのみでCの極限未満のすべての順序数を表現可能

すべての帰納的順序数を引数に取れる test ** 命令は、
>>233 のようなマシンでは定義が非常に複雑になるが、
C++ のような高級言語なら出来そうである。

>>266 のように、ordinalを、0 から始めて再帰的に、
１個前の順序数を使って定義する
収束列を使って定義する
としていけばすべての帰納的順序数を表現できる。
これを引数にとるような test ** 命令を持つマシンでの
n命令での最大のステップ数が M[帰納的でない最小の順序数](n) である。
（>>269 でいう ☆_0）
さらに、☆_a をあらかじめ定義しておくことで、
M[★_0](n), M[☆_2](n) なども定義できる。

ただ、このようなルールはマシンを定義する段階で必要であるので、
すべての順序数を定義できるわけでなく、
いままで人間が到達出来ていない最小の順序数
のようなものに対してマシンを定義できない。

たとえば、M[Ω](n) なんかは、可算順序数がすべて表現可能な
方法が見つかってから始めて定義できる。...つまり定義できない。

ということで、
>>280 の後半「順序数の比較は不可になる」というのは嘘で、
M[順序数](n) として大小比較が出来そう。

----
☆_0 の収束列を、
C++ n語で表現できる最大の帰納的順序数
とすれば、
F[☆_0](n) が定義できる。
「C++ n語で表現できる最大の帰納的順序数」を求めるアルゴリズムは存在しないため、
これは BB と同程度の大きさとなる。
F[帰納的順序数](n) はすべて計算可能であり、
すべての計算可能な関数は、F[ある帰納的順序数](n) で押さえられる。

M[0](n) ≒ F[☆_0](n) であり、
M[1](n) ≒ F[☆_1](n) であり、
おそらく、M[a](n) ≒ F[☆_a](n) といえる。

こんにちは。見てます。何とか見てます。
さっぱりです。
何とかします。

http://www.polytope.net/hedrondude/scrapers.htm
ここに載ってるのとふぃっしゅ数だったらどっちがでかいのか？

表記法の説明（英語）
http://www.polytope.net/hedrondude/array.htm

ふぃっしゅ数の定義はこれ？
http://www.geocities.co.jp/Technopolis/9946/log/ln023.html

S変換がハーディー関数の順序数にωを足す位の変換。
つまり、F[a](n)にS変換を行うとF[a+ω](n)になる位。

SS変換はω^2を足すのと同等、
SSS変換はω^3を足すのと同等、
....
S^i変換はω^iを足すのと同等、
--------
(S^n変換)f(n) ≒ F[a+ω^ω](n)

最初の関数にアッカーマンを使っているが、
f(x) = x+1 としても大差なし。どちらもF[ω^ω](n)程度となる。

>>281の多変数＃と同程度。

>>286 のほうは、定義が複雑でよくわからないが、
Extended Operators の下の方の4変数の段階で F[ω^2](n) 程度。

http://www.geocities.co.jp/Technopolis/9946/log/ln051.html
こちらの >>10 にバージョン５の記述がありましたね。

m(2) がハーディー関数の順序数に1を加えるのと同等、
m(3)m(2) がハーディー関数の順序数にωを加えるのと同等、
m(4)m(3)m(2) がハーディー関数の順序数にω^2を加えるのと同等、
....

f5(n) ≒ F[ω^ω](n)
となり、古いバージョンとほぼ同じとなるようです。

ふむう。だいぶ研究が進んでるようですね。
いよいよこのスレの終焉も近い？

あ、ちょっと解釈を間違ってたかもです。
>>289は取り消し。

ふぃっしゅ数バージョン５の大きさ（訂正）

m(2) がハーディー関数の順序数に1を加えるのと同等、
m(3)m(2) がハーディー関数の順序数にωを加えるのと同等、
m(4)m(3)m(2) がハーディー関数の順序数にω^ωを加えるのと同等、
m(5)m(4)m(3)m(2) がハーディー関数の順序数にω^ω^ωを加えるのと同等、
....

f5(n) ≒ F[ε_0](n)

ﾌﾞｰﾝが沢山いるスレだな…

てすと

保守

無限大が無限大にある、という言い方もできますが、この場合は
無限大を超えることになる。
無限大×∞
∞＾∞
∞＾∞＾∞　とかぎりなく増やせるということは、
さらに、上数があるということだろうか？

>296
∞ = 1+1+1+…
として
2∞ = (1+1+1+…)+(1+1+1+…)
　　 = 1+1+1+1+1+1+…
としてしまうと∞と変わらなくね？となるので
「1が無限個ある」はまだいいけど「1が2∞個ある」は禁止。
きちんと掛け算を定義しないといけなくてそれをやってるのが順序数。
で
「∞に＾∞を無限個つなげる」から先はどうすればいいんでしょうね。

アレフ0とアレフ１じゃないのか？

順序数のことじゃないのか？
∞ ==> ω

とりあえず有志が整理しないとω?SS変換???てことになるぞ

ωは「最小の超限順序数」だから
ω+1とか定義できるしなあ。
>>297の言いたいこととはちょっと噛み合ってないんじゃないかと思われ

私のExploding Array Functionは私が数年前に開発した様々なアレイ記法の一般化された
フォームです、(直線的)のアレイ記法や、広げられて(次元)のアレイ記法や、いくつかの
変更があるtetrationalアレイ記法などのように。 元々、様々なアレイ記法には、いくつ
かの規則がありました--直線的のための5、広げる、私がtetrationalであっ、それでも、
今それを解決しようとして、3つの規則しかなくて、すべてのアレイの世話をするtetrati
onalアレイのずっとも先の7。
--------------------------------------------------------------------------------

どのように、それ、Started
数年間、私は数多く興味を持っています、数個のために名前を鋳造しさえするまで私の
「「不-ライオン」番号」ページを参照してください。 ある日(およそ20年前)、私は強国を
超えたオペレータ、tetrationなどのオペレータ、pentation、hexationなどについて議論し
たものを本(名前を覚えていない)に読み込みます。 これによって、私は次元スペース(私が
現在呼ぶ空間、最高の次元の、そして、trimensionalなquadramentionalなど)を超えた極端
な空間と同様により極端な数を調査したくなりました。 時間が経ったように、私はその本の
見られるオペレータにextentionを開発し始めました、私が拡張オペレータに言及するつもり
であるこれら。 その後、AckermannのFunctionやコンウェイのChained Arrow Notationなど
の知られている大きい数の機能を調べた後に、私はこれらのよく知られている機能と拡張オ
ペレータを比べることができました。 オペレータのはるかに凌がれたAckermannのFunctionを
広げて、実際にコンウェイのChained Arrowと比較することができました--詳細がないかどうか
M.ロブの大きい数のページでチェックしてください。 その後、私は拡張オペレータを広げる
タスクを引き受けました--私は、後で4つの番号、および次のextentionが5時までに拡張オペ
レータを定義することができると発見しました。 これは私のArray Notationの開発の始まり
です。

機械翻訳かけるぐらいなら原文引用しろよ…

>>302は自分じゃ日本語が話せないんじゃないの？

なるほど。
>>302
You might wanna post it in English.

俺用まとめ。

足し算a+bは1を足すのをb回繰り返す
掛け算a*bはaを足すのをb回繰り返す
階乗a^bはaかけるのをb回繰り返す
タワーa↑↑bはaをb乗するのをb回繰り返す
タワーa↑↑↑bはa↑↑bをb回繰り返す
タワーa↑^nbはa↑(n-1個)bをb回繰り返す
これを改良したのがコンウェイのチェーン表記

アッカーマン関数
　原始帰納的でない帰納的関数
　　ack(0,n)=n+1
　　ack(1,n)=n+2
　　ack(2,n)=2*n+3
　　ack(k,n)はack(k-1,n)と階乗を使って表わせる。

以下、俺の理解
バード数
　タワーと、グラハム数を使った関数を用いた数。
ふぃっしゅ数
　バージョン1のS変換は↑^nのこと
　その次のS変換(SS変換?)は↑の代わりにアッカーマン関数を使ったもの
　それらの変換を使って定義した数
ビジービーバー関数
　どんな計算可能な関数よりも増加率の大きい関数。
　「じゃあ、俺今まで出た一番でかい関数+1ね。」っていうズルと一緒
ハーディ関数：ω(無限順序数のうち最小のもの)が計算可能でないのでズルに思える。

多分、S変換とバード数の回転だと、初期の値の振る舞いはバード数が勝つ(グラハム数を使っているため)が
基本的にタワーよりはアッカーマン関数のほうが増加率が大きいので
グラハム数を...回適用する程度の差は吸収されて、S変換を使った数のほうが大きくなるように感じる。

あまたがわるそうなやつのまとめだな。

とりあえずこのくらいの認識から初めて、ちょっとずつ改めまていけばおｋ

ぐらいには上手くまとまってる。

>>306
おかしなところを指摘しておく。

＞タワーa↑↑bはaをb乗するのをb回繰り返す
　この書き方だと、a↑↑b=((a^b)^b)^b…=a^(b^b)という意味にとれてしまう。
　もしかしたら、「aの○乗というのをb回繰り返す」と言いたかったのかもしれないけど。
＞ack(k,n)はack(k-1,n)と階乗を使って表わせる。
　ack(ｋ,n) = ack(ｋ-1,ack(ｋ,n-1))だから、階乗を使って表すことはできないだろう。
＞「じゃあ、俺今まで出た一番でかい関数+1ね。」っていうズルと一緒
　ビジービーバー関数の値は他に依存せずに定義されているから、
　そういう他に依存した定義をするズルとは違う。
　ただ、「計算可能」でないと、他の「計算可能」でない関数と大小比較をするのも難しいし、
　具体的な計算手順が分からなくて面白みに欠けるから、このスレではあまり深く扱われないのだと思う。
　（ここでいう「計算可能」とは、簡単にいえば、与えられた引数から関数の値を計算するプログラムが書けるということ。）
＞ω(無限順序数のうち最小のもの)が計算可能でないのでズルに思える。
　ここで”計算可能でない”と言ってるのは、単にωが「普通の数」ではないという意味だと思う。
　ただ、そういう「普通でない数」を使っていても、各順序数に対して定まる関数は「計算可能」であるから、
　（例えばH[ω](x)=2xだから、H[ω]は「計算可能」な関数）
　ハーディ関数自体はズルではないと言える。

バード数とふぃっしゅ数についてはよく覚えてないので、指摘はしない。

バード数の定義はこれ？
http://www.geocities.co.jp/Technopolis/9946/ambitious.html

X_1(n) ≒ F[ω^3+1](n)
X_a(n) ≒ F[ω^3+a](n)
X_n(n) ≒ F[ω^3+ω](n)

入れ子操作n回 ≒ [ω^3+ω+1](n)

n回回転チェーン↑n(3,3,3) ≒ F[ω^3](n) だから
ほとんど増えていないことに。

大きさのまとめ

Knuthの上矢印 3(↑^n)3 ≒ F[ω](n)
Ak(n, 3) ≒ F[ω](n)
n個のnからなるConwayのチェーン ≒ F[ω^2](n)
チェーンの回転 ↑n (3,3,3) ≒ F[ω^3](n)
バード数の定義の X_n(a) の入れ子操作n回 ≒ F[ω^3+ω+1](n)
5変数Ak ≒ F[ω^4](n)
多変数Ak Ak(n個のn) ≒ F[ω^ω](n)
Ak を２重リストに拡張、Ak([n個のn], [n]) ≒ F[ω^ω^ω](n)
ふぃっしゅ数バージョン５のf5(n) ≒ F[ε_0](n)

>>309
計算可能でない関数の比較も順序数を用いて出来る。
>>282 付近参照。

>>309
>この書き方だと、a↑↑b=((a^b)^b)^b…=a^(b^b)という意味にとれてしまう
確かに。補足さんくす。
a^b^cはa^(b^c)だな。
^以降では、交換法則が不成立性なのはすぐわかるんだが、結合法則はどうやって示すんだろ
　2+2+2=3+3が成り立つから2*3=3*2
　2*2*2=3*3が成り立たないから2^3=3^2じゃない

ackについては、もう少し書くと
　ack(3,n)=2^(n+3)-3
　ack(4,n)=2^(2^n+3)-3
　ack(5,n)=2^(2^(2^n+3))-3
　↑細かくは間違っているかもしれんがふいんきをつかんでくれ
　ack(k,n)とack(k-1,n)を再帰の定義の関係としてでなくて
　ack(k,n)の一般項とack(k-1,n)の一般項の関係でみればいい。
　つまり、ackは高階原始帰納的関数というわけ

hardy functionに関しては、n<ωの時はこうなるよな？
　3(↑^n)3<ω
　Ak(n,3)<ω
　↑n(3,3,3)<ω
n>=ωの場合は、計算の仕方がわからん・・
>そういう他に依存した定義をするズルとは違う。
違わないと思う。
ttp://www.ice.nuie.nagoya-u.ac.jp/~h003149b/lang/undecidable.html

>>313
>  　ack(4,n)=2^(2^n+3)-3
>  　ack(5,n)=2^(2^(2^n+3))-3
これじゃ原始帰納だよ

あまたがわるそうなやつがまたきた。

> ^以降では、交換法則が不成立性なのはすぐわかるんだが、結合法則はどうやって示すんだろ
(3^3)^3 ≠ 3^(3^3)

> ackについては、もう少し書くと
どこをたてよみ？

> hardy functionに関しては、n<ωの時はこうなるよな？
「hardy function に関しては」と書いているのに hardy function が出てこない不思議。

>> そういう他に依存した定義をするズルとは違う。
> 違わないと思う。
自分が理解できないからってズルか。

あたまがわるいふりをした釣り？

>>313
ackとチェーン表記については、ack(m,n)=2→(n+3)→(m-2) - 3という関係式が成り立つようだ。
ただ、m=0を代入すると右辺の計算ができないからm>0とする。
（a→b→(-1) = a+b, a→b→0 = a*bとしておく）

どうやら、>>306では「階乗」という言葉を"！"以外の意味で使いたかったようだな。

hardy functionに対しては何を言いたいのか分からないので、
もう一度hardy functionのことを勉強してから書き直してほしい。

ビジービーバー関数みたいな定義をズルと感じるかどうかは、人によって違うかもしれない。
関数に対して具体的な計算手順を定めなければいけないと考えるなら、
ビジービーバーみたいな具体的な計算手順を与えない定義はズルだとも言える。
ただ、この場合は暗黙のうちに「計算可能」な関数のみを考えているということになる。
一方、関数というのはある引数に対してある値が定まりさえすればいいと考えるなら、
ビジービーバー関数もズルではないということになる。
いずれにしても、「今まで出た一番でかい関数+1」というのは状況によって異なる関数になってしまうから、
まともに定義しているとは言えず明らかなズルだと言える。

結局、客観的に見てズルかどうか判断するには、ルールや暗黙の了解が必要になる。
そういうものがあれば、それに反するものがズルだと客観的に判断できる。
現状では「計算可能」な関数に限るというルールも暗黙の了解もないから、
ビジービーバー関数がズルだと言っても単なる個人の意見でしかない。

ビジービーバー関数がズルだという主張も理解できなくはないけどな。
「今まで出た一番でかい関数+1」というのは他に依存した定義だから悪いというのなら、
他に依存しないように定義すればいい。他に依存しない定義をするためには、
あらゆる可能性をあらかじめ考えてその中で最大のものを選び出せばいい。
「あらゆる」といってしまうときりがないから、「ｎ文字以下のプログラム」とか制限をつければいい。
とやって行き着くところがビジービーバー関数だとも言えなくはないわけで。

> いずれにしても、「今まで出た一番でかい関数+1」というのは状況によって異なる関数になってしまうから、
> まともに定義しているとは言えず明らかなズルだと言える。

単に+1するのに14文字も費やして非常に効率が悪いのでだれも見向きもしないけど、
14文字である関数を非常に大きく出来るならそれはそれで意味があると思う。
S変換なんかは関数を大きくする変換だしね。

計算可能じゃない関数がズルだとかいっていたらそこで進歩は止まるよ。
虚数なんかは数じゃないといって否定するようなもの。
実際ビジービーバー関数よりずっと大きな関数も出てきてるし。

>>317
別に、計算可能じゃない関数がズルだと316で主張したいわけではない。
ビジービーバー関数に違和感を感じる人の気持ちも理解できなくはないというだけで。

個人的な考えとしては、計算可能な関数に限って大きいものを考えるのも、
計算不能な関数も含めて大きいものを考えるのも、どちらも意味あることだと思う。
実数の範囲のみで考えることも、複素数の範囲まで広げて考えることも、どちらも意味があるように。

>>317 の下３行は >>316 宛じゃない。過剰反応。

313は間違ってた。316さん補足どうも。
理解コストの高そうなのはスキップして前スレ一通り読んでみた。
俺の印象では計算不可能な巨大数だと、到達不能基数を除いてε数が強げ。

そんでωを表わすためのC言語の関数を考えてみた
　big w(){return 1+w();} //bigは多倍長正数型(つか、値より停止性にしか意味ないような)

この関数の返す値(もちろん計算可能でない)をωとする
するとw()の多項式は、順序数ωの計算同様、右分配法則を満たさない
1+w()はw()に吸収されるからw()の値と同じ→1+ω=ωのアナロジー
n+w()はw()に吸収されるからw()の値と同じ→n+ω=ωのアナロジー
2*w()はw()に吸収されるからw()の値と同じ→2*ω=ωのアナロジー
n*w()はw()に吸収されるからw()の値と同じ→n*ω=ωのアナロジー
w()+1はw()で計算がとまる→ω+1≠1+ωのアナロジー。残りも同様

あと、ack3項版を作ってみた
　1.ack(0,0,z)=z+1
　2.ack(0,y,0)=ack(0,y-1,1)
　3.ack(x,0,0)=ack(x-1,ack(x-1,1,0),0)
　4.ack(x,0,z)=ack(x-1,z+1,0)
　5.ack(0,y,z)=ack(0,y-1,ack(0,y,z-1))
　6.ack(x,y,z)=ack(x-1,ack(x,y-1,z),ack(x-1,y,z))
☆ack(0,m,n)は2項のack(m,n)と一致する
停止性を満たしたまま1,2,5式を残せば☆を満たせる。
つまり、ackのn項化って色々やり方がある
多重帰納法の種類だけ、作れるんじゃなかろうか

あまたがわるそうなやつがまたきた。

> 俺の印象では計算不可能な巨大数だと、到達不能基数を除いてε数が強げ。
計算可能という意味をまず理解したほうがいい。

> big w(){return 1+w();} //bigは多倍長正数型(つか、値より停止性にしか意味ないような)
> この関数の返す値(もちろん計算可能でない)をωとする
無限ループとなり値は返らない。

> あと、ack3項版を作ってみた
複雑なわりに大して大きくなってない。
3変数ならもっとずっと大きく出来る。

>>320
ackやチェーン表記みたいな巨大関数の拡張案は過去に何度も出ているが、
その多くは元の関数にあった単純さを失ってる上にそれほど大きくないものになっている。
単純で巨大な計算可能関数としてはHardy関数があるし、
ただの拡張案で大きな関数を目指すことにはほとんど意味がないと思う。

あと、「ωはどんな自然数よりも大きい」とかの説明を聞くと、
順序数自体を巨大数として扱うのだと思ってしまう人がいるが、
順序数は単に巨大な自然数を作るための道具として使われてるだけのはず。
順序数から巨大関数を作るための手段の一つがHardy関数。

Hardy関数や >>282 のような関数は非常に強力であるが、
これだけだと、単に大きな順序数を考えることと同じになってしまう。

Hardy関数、順序数やチューリングマシンの概念を使わずに
シンプルに、もしくは新しい方法で巨大な関数を作ることは十分意味があると思う。

Hardy関数と比較することで大きさの評価も比較的簡単になったし。

今のところHardy関数やチューリングマシンを使わない最大は、
ふぃっしゅ数バージョン５ （F[ε_0] 相当の関数） であろうか。

----
ちなみに、
>>320 のack は F[ω+ω](n) 程度の大きさ。

以下のように定義すれば、よりシンプルで F[ω^2](n) 程度まで大きくなる。
（こんな簡単な定義でコンウェイのチェーンでn個のnを結んだものと同程度になってしまう）

1.ack(0,0,z)=z+1
2.ack(x+1,0,z)=ack(x,z,z)
3.ack(x,y+1,0)=ack(x,y,1)
4.ack(x,y+1,z+1)=ack(x,y,ack(x,y+1,z))
※x, y, z は非負整数

多変数や多重リストへの拡張は >>281 の up2950.txt 参照。

数学板でこのスレが一番おもしろいな

あげときます

★１つ目の関数
A(n)では非負のnは1以下。パラメータの階層と、最上階層のパラメータの数はともに1。
A(0)=2 （初期値）
A(1)=A(0)^A(0)^A(0)=2^2=4
(=2↑↑2)

★２つ目の関数
この4が次のパラメータの階層と、最上階層のパラメータの数になる。すなわち、
A(n_1_1(n_1_2(n_1_3(n_1_4))),n_2_1(n_2_2(n_2_3(n_2_4))),n_3_1(n_3_2(n_3_3(n_3_4))),n_4_1(n_4_2(n_4_3(n_4_4))))
３つ目の関数に移行するためには、(5^(4*4)-1≒1.5^11)回の計算を経なければならない。

A(0(0(0(0))),0(0(0(0))),0(0(0(0))),0(0(0(0))))=A(1)=4
A(0(0(0(0))),0(0(0(0))),0(0(0(0))),0(0(0(1))))=4↑↑↑↑4=4→4→4
A(0(0(0(0))),0(0(0(0))),0(0(0(0))),0(0(0(2))))=(4→4→4)↑↑＜4→4→4個＞↑↑(4→4→4)
=(4→4→4)→(4→4→4)→(4→4→4)
A(0(0(0(0))),0(0(0(0))),0(0(0(0))),0(0(0(3))))=[(4→4→4)→(4→4→4)→(4→4→4)]→[(4→4→4)→(4→4→4)→(4→4→4)]→[(4→4→4)→(4→4→4)→(4→4→4)]=あ
A(0(0(0(0))),0(0(0(0))),0(0(0(0))),0(0(0(4))))=あ→あ→あ
A(0(0(0(0))),0(0(0(0))),0(0(0(0))),0(0(1(0))))=(あ→あ→あ)→(あ→あ→あ)→(あ→あ→あ)=い
A(0(0(0(0))),0(0(0(0))),0(0(0(0))),0(0(1(1))))=い→い→い
A(0(0(0(0))),0(0(0(0))),0(0(0(0))),0(0(1(2))))=(い→い→い)→(い→い→い)→(い→い→い)

★３つ目の関数
２つ目の関数の最後、
A(4(4(4(4))),4(4(4(4))),4(4(4(4))),4(4(4(4))))
はすでにグラハム数ですら無に等しいほどの巨大数となっている。仮にこれを「う」とする。
３つ目の関数は「う」の階層を持ち、最上階層の数が「う」のパラメータを持つことになる。
４つ目の関数に移行するには「(う+1)^(う*う)-1」回の計算を行わなければ成らない。

★64番目の関数
「ふぃっしゅ数」を軽く超えているものと予想される。

>>326
どのくらい大きいのかはよく分からないけど、なんだか昔の
スレッドに戻ったみたいでほのぼのした。

とはいっても、基本形がすべて
○→○→○
だから、イマイチ増加率が大きくないことに気づく。
ただ、関数を１つ上げるために必要な項の増加率が膨大だから、どちらが大きくなるか。

語弊を招くことを承知で極論すれば、
「ある等差数列の1無量大数項目と、ある等比数列の百項目のどちらが大きいか」
と同じ話だ。

>>326
定義を誤解しているかもしれないが、思ったことを書いておく。
パラメータの数が多い割には、その多さが活かされていないと思う。

f(x)=x→x→xとすると、「う」というのは、f^{5^(4*4)-1}(4)と表される。
（f^n(x)は、xにfをn回適用した数とする）
n番目の関数でパラメータに最大値を代入したときの値をg(n)と表すと、
g(1)=4, g(n+1)=f^{(g(n)+1)^(g(n)*g(n))-1}(g(n))という漸化式でg(n)を表すことができる。

g(n)の大きさを見積もるためにHardy関数を用いると、
f(x)≒F[ω], g(n+1)≒f^{g(n)}(g(n))なので、g(n)≒F[ω+2](n)程度の大きさということになる。
過去ログによると、ふぃっしゅ関数ver.1はF[ω^2*63]程度の大きさということなので、
残念ながら326の関数ではふぃっしゅ数ver.1にも及ばない。

定義を解釈するときに、A(0(0(0(0))),0(0(0(0))),0(0(0(0))),4(4(4(4))))=☆として、
A(0(0(0(0))),0(0(0(0))),0(0(0(1))),0(0(0(0))))=☆→☆→☆のように計算するのだと解釈したが、
この解釈がもし間違っていたら指摘してほしい。

>>329
はい、その通り。返す言葉もございません。
私も未明の書き込みの時点でふぃっしゅ数に遠く及ばないだろうと感じていた。

もともとこの式は、
・高校生でも理解できる関数（↑までは容易に理解できると思われるので）
・パラメータを爆発的に増やすことで「それなりに」大きな数を作ることを試みる
を満たそうと考えたのもので、これはその最も原始的なものという扱いです。
グラハム数やふぃっしゅ数とどちらが大きいかもまったく検証してなかった。ごめんなさい。

関数自体の増加率もパラメータの数もさらに増やすことは容易なので、
修正すればもう少し大きな数ができるかもしれない。
ふぃっしゅ数に勝てるかはわからんが、パラメータにも前項の式を代入できるようにすればあるいは…

3/3=1

x→x→x→x よりも小さいんじゃ意味ねえ。

ある項は、その前の項Akを(((AkのAk回乗数繰り返し)回乗数繰り返し)…(AkのAk回乗数繰り返し)…)回乗数を繰り返す。
つまり、ある項A_k+1はその前の項までAkを用いて、
A_k+1 = Ak^Ak^…(Ak↑↑Ak…(Ak↑↑Ak 回)…Ak↑↑Ak 回)…^Ak^Ak
A_k+1 = Ak^Ak^…(Ak↑↑↑Ak 回)…^Ak^Ak = Ak↑↑↑↑Ak = Ak→Ak→4

ある関数のパラメータは、その前の関数の最後の項の数Ｃだけ最上階層パラメータをもつ。
各最上階層パラメータはそれぞれＣだけ２次パラメータを持ち、さらにその２次パラメータはそれぞれＣだけ３次パラメータを持つ。
パラメータの階層はＣある。
すべてのパラメータmはm(i1,i2,i3,…,in)(1≦n≦C)と表記される。ここでi1,i2…は最上階層、次の階層…の値。
各パラメータには順序があり、i1が小さいもの、その中でi2が小さいもの、その中でi3が小さいもの、…から計算される。
たとえばC=3のとき、
A(あ(い(う,え,お),か(き,く,け),こ(さ,し,す)),せ(そ(た,ち,つ),て(と,な,に),ぬ(ね,の,は)),ひ(ふ(へ,ほ,ま),み(む,め,も),や(ゆ,よ,ら)))
とパラメータがおかれ、「ら」が最大値となったとき「よ」が1つ加算され、
「ら〜せ」がすべてそれぞれ最大値となった時「す」が1つ加算され、となる。
また、あ→ら にかけて上位→下位のパラメータと定義する。
すべてのパラメータがそれぞれ最大値をとったとき、次の関数に移行する。

各パラメータは1からB(l)の値をとる。
ここで、あるパラメータの値が1つ下位のパラメータの最大値B(l-1)に達した時の、項の値をB(l)とする。

このとき、1つ上位のパラメータに移行するには、
B(l+1) = A_(k+B(l))
A_(k+B(l+1)) = A_(k+A_(k+B(l))) = A_(k+(Ak→Ak→4)→B(l)→2)
A_(k+B(l+1)) = (Ak→Ak→4)→((Ak→Ak→4)→B(l)→2)→2 (B(l)<Ak)

次の関数に移行するには…


やめた。326よりは確実に大きくなっているが、これだけややこしい説明してもグラハム数には及ばない。
高校生にも簡単に理解できて、かつグラハム数を超える数は作れないのか…
ちなみに高校生っていうのは、理屈の上ではタワー表記を使わずに説明できること（便宜上使ったが）

>>333
＞高校生にも簡単に理解できて、かつグラハム数を超える数
>>323の3変数アッカーマン関数で、ack(1,1,100)とするだけでグラハム数を超えると思う。
ack(1,0,x) = ack(x,x)=2→(x+3)→(x-2) - 3だから大雑把に見てack(1,0,x)≒3→3→xで、
ack(1,1,x)はack(1,0,x)をx回繰り返すのと大体同じくらいになるので、
3→3→xを4に64回適用したグラハム数よりack(1,1,100)の方が大きくなるはず。
左の方の引数を増やせば、もっと大きい数を作ることもできる。

そもそも、パラメータを増やすとごちゃごちゃしてくるのでかえって分かりにくくなってしまう。
あと、パラメータに最大値があるというのも、あまり大きくならない原因の一つだと思う。
それから、パラメータに階層構造があるのに、それが活かされていない。
たとえば、326の2つ目の関数では、括弧を取り除いて16個のパラメータを並べても同じ関数になる。

巨大数作りではよくあることだが、数を爆発的に大きくするための要点があって、
その要点をうまく抑えれば単純な定義でも非常に巨大な数が作れる。
逆に、その要点を外すとどんなに複雑な定義をしてもたいして大きくならない。

それがはっきり分かる一例としては、>>323の3変数アッカーマン関数がある。
たった3変数で、たった4つの定義式しかないのに、一番左の引数を大きくすれば
チェーン表記を伸ばすのと同程度の速さで増大していく。

>>334
詳しい解説サンクス。
私も326を書き込む前に3変数アッカーマン関数を見て驚いた。
これは単純ながら強力だなあと感心した。
（じゃあ複雑化しただけで使い道のない関数作ってないでそれ使えよという突っ込みはなしで）
変数に関数自体を格納してしまうのが賢いとは分かっていながら、同じ手法使っても面白くないし。

読む気も失せる333だが、これは326を改良したものである。
どちらも結局、増加率には乗数しか使っていない。
パラメータにもなんら関数は格納していないし（順番に1ずつ増えていくだけ）、
ひどく原始的な手法で巨大数を作ろうという試みだ。

恐れ多くもこれでグラハム数を超えようとは呆れたものだ。
いまさらだが結局、乗数だけに頼っていては限界があるという愚例になったと思う。
（さらにまどろっこしい説明を加え続ければｘ→ｘ→ｘ→ｘを説明できないこともないが、無益なのでやめ）

>>323
なるほど。ふぃっしゅ数バージョン５の意味付けをしていただき
ありがとうございます。

>>311
こうやって整然と比較できるのが、Hardy関数の威力ですね。

せっかくなので、これまでのふぃっしゅ数について
http://www.geocities.co.jp/Technopolis/9946/log/thread6.html
ここの531、544を参考にして大きさを評価すると、

ふぃっしゅ数バージョン1のSS変換n回：F[ω^2+1](n)
ふぃっしゅ数バージョン2のSS変換n回：F[ω^3](n)
ふぃっしゅ数バージョン3のs(n)：F[ω^ω](n)

といった感じになりましょうか。

ちなみに、
http://www.geocities.co.jp/Technopolis/9946/log/ln051.html
ここの115に出てくるSnakeは、どの程度の大きさになりますか？

>>323では、F[ω^2]程度の関数をシンプルに表記していますが、
F[ω^ω]程度、あるいはF[ε_0] 程度の関数を出来るだけシンプルに
表記するにはどうすればいいか？といった問題設定もできそうですね。
なにをもってシンプルとするかは主観ですが…。

>>336
Snake の定義の３つ目の式を、
　Snake([a<1>,･･･,a<n>],x)
　=Snake([a<1>,･･･,a<n>-1],Snake([a<1>,･･･,a<n-1>,1],x))
と解釈し、
　Snake([1],x) = x+1
とした場合は、

Snake([1がn個], n) ≒ F[ω^ω](n)

「なにをもってシンプルか」という解のひとつが、
>>260 でしょう。

>>281 でアップしたものをもう一度アップしておきます。
http://1rg.org/up/46579.txt.html

ついでに、定義自体に順序数を使わない大きな関数です。
概念的には順序数＋Hardy関数ですが、
順序数を知らなくても、頑張れば理解できるかも。
http://1rg.org/up/46580.txt.html

>>338
保存しておきます
http://symy.jp/m1mG
http://symy.jp/Lo51

>>338
難しいですね…。

「概念的には順序数＋Hardy関数」とのことなので、
Hardy で F[ω^2], F[ω^ω], F[ε_0] に相当する
大きさの H[A] を作ると、Aの値はどうなりますか？

>>340
H[((((0)))0)] ≒ F[ω^2](n)
H[(((0)0)0)] ≒ F[ω^ω](n)
H[((0)00)] ≒ F[ε_0](n)
H[(((0))00)] ≒ F[η_0](n)
H[((0)000)] ≒ F[Γ_0](n) = F[ψ(0)](n)
H[((0)(0)00)] ≒ F[Γ_Γ_...Γ_0](n) = F[ψ(Ω)](n)
H[(((0))000)] ≒ F[ψ(Ω^2)](n)
H[((0)0000)] ≒ F[ψ(Ω^3)](n)
H[((0)00000)] ≒ F[ψ(Ω^4)](n)
H[((0)00.....n個.....00)](n) ≒ F[ψ(Ω^ω)](n)

それでは、感覚をつかむために H[((((0)))0)] ≒ F[ω^2](n) から計算してみます。
まずは、>>338の定義をコピーします。

Ｎ:非負整数 とする (0, 1, 2, .....)

■集合Ｔ
○定義
0 ( ) の３つの文字からなる文字列の集合で、以下の２つの条件を満たす最小のもの

"0" はＴの元である
Ｔの元を１個以上有限個繋げて () でくくったものはＴの元である

演算子 + で文字列の連結を表す
"(0)" + "0" = "(0)0"

○意味
葉が0の多進木
0と多変数の関数funcで生成できる数 と対応する
"(000)" => (0,0,0) => func(0, 0, 0)
"((0)0(0)((0)0))" => ((0),0,(0),((0),0)) => func( func(0), 0, func(0), func( func(0), 0 ) )

■Seq : Ｔ×Ｎ => Ｔ
○定義
Seq は Ｔ×Ｎ から Ｔ への関数であり以下を満たす

s = "0" の時
Seq(s, i) は未定義

s = "(" + □ + a + ")" の形の時
Seq(s, i) = a

s = "(" + Ｘ + B + □ + a + ")" の形の時
Seq(s, 0) = "(" + a + ")"
Seq(s, i+1) = "(" + Ｘ + Seq(B, i+1) + Seq(s, i) + □ + ")"

ただし、
s, a, b, B ∈ Ｔ ただし、B ≠ 0
□ : 0個以上の0を有限個繋げたもの
Ｘ : 0個以上のＴの元を有限個繋げたもの
i ∈ Ｎ

■H[a] : Ｎ => Ｎ
○定義
a ∈ Ｔ とし、H[a] で Ｎ => Ｎ の関数を表し以下を満たす

H[0](n) = n+1
H[A](n) = H[Seq(A, n)](n+1)

ただし、
A ∈ Ｔ, A ≠ 0

【略号】

(1) = ((0))
(2) = (((0)))
(3) = ((((0))))
(i,j) = (i)(i)(i)…j+1個…(i)
0^i = 000...i個…0

【Seq の計算】

Seq((0), i) = 0
Seq((n), i) = (n-1)
Seq(((n+1,1)), i+1) = (Seq((n+1), i+1) + Seq(((n+1,1)), i))
= ((n) + Seq(((n+1,1)), i))
= ((n, i) + Seq(((n+1,1)), 0))
= ((n, i) + (n+1))
Seq(((n+1,m+2)), i+1) = ((n+1,m) + Seq((n+1), i+1) + Seq(((n+1,1)), i))
= ((n+1,m) + (n, i) + (n+1))
Seq(((n+1) + 0), i+1) = (Seq((n+1), i+1) + Seq(((n+1) + 0), i))
= ((n) + Seq(((n+1) + 0), i))
= ((n, i) + Seq(((n+1) + 0), 0))
= ((n, i) + 0)
Seq(((n+1, m+2) + 0), i+1) = ((n+1,m) + Seq((n+1), i+1) + Seq(((n+1) + 0), i))
= ((n+1,m) + (n, i) + 0)
Seq((0, m+2) + 0, i+1) = ((0,m) + Seq((0), i+1) + Seq(((0, m+2) + 0), i))
= ((0,m) + 0 + Seq(((0, m+2) + 0), i))
= ((0,m) + 0^(i+2))

【H[((((0)))0)] の計算】

H[((((0)))0)](n) = H[((2)0)](n) = H[Seq(((2)0), n)](n+1)
= H[((1, n-1) + 0)](n+1)
= H[Seq(((1, n-1) + 0), n+1)](n+2)
= H[((1, n-3) + (0, n) + 0)](n+2)
= H[Seq(((1, n-3) + (0, n) + 0), n+2)](n+3)
= H[((1, n-3) + (0, n-2) + 0^(n+3))](n+3)
= H[Seq(((1, n-3) + (0, n-2) + 0^(n+3)), n+3)](n+4)

Seq((X + (0, n-2) + 0^(n+3)), n+3)
= (X + (0, n-3) + Seq((0), n+3) + Seq((X + (0, n-2) + 0^(n+3)), n+2) + 0^(n+2))
= (X + (0, n-3) + 0 + Seq((X + (0, n-2) + 0^(n+3)), n+2) + 0^(n+2))

普通に計算したのでは、歯が立たないかな。

また、改めて出直してきます。

簡単に解説します。

http://web.mit.edu/dmytro/www/other/OrdinalNotation.htm
順序数の生成にはこれを参考にしたC0を使っています。
（Cの一番小さいものを多変数にしたもの）
veblen関数の多変数に比べて変数１個分小さいですが、
その分、加算の定義が不要となります。

-----------C0-----------
●定義
　C0(□, a) = a+1
　C0(Ｘ, b+1, a) = lim { 初項 a / ２項目以降 C0(Ｘ, b, １個前の項) }
　C0(Ｘ, b+1, 0, □, a) = lim { 初項 a / ２項目以降 C0(Ｘ, b, １個前の項, □, a) }
　C0(Ｘ, B, □, a) = lim C0(Ｘ, B_n, □, a)

　ただし、
　　a, b : 順序数
　　A, B : 極限順序数 （A_n, B_n : 収束列）
　　□ : 0個以上の0
　　Ｘ : 0個以上の0以上の順序数

●大きさ
　C0(a) = a+1
　C0(a,0) = ω^a
　C0(1,0,0) = ε_0
　C0(2,0,0) = η_0
　C0(1,0,0,0) = Γ_0
　C0(1,0,0,0) = Γ_Γ_...Γ_0
　C0(2,0,0,0) = ψ(Ω^2)
　C0(1,0,0,0,0) = ψ(Ω^3)
　lim C0(1,0,0,....n個.....,0,0) = ψ(Ω^ω)

集合ＴはC0で生成する順序数と対応しています。

"0" => 0
"(0)" => 1
"((0))" => 2
"(((0)))" => 3
"((0)0)" => C0(1,0) => ω
"(((0))0)" => C0(2,0) => ω^2
"((0)00)" => C0(C0(0),0,0) => ε_0
"((0)000)" => C0(C0(0),0,0,0,0) => Γ_0

Seq(s, i) は、順序数が極限の場合はその収束列を返し、
順序数がa+1の形の場合はaを返します。

H[a] はaが後続順序数と極限順序数の時の定義をくっつけた
ハーディー関数になります。

>>341 間違ってました。訂正。
H[((((0))0)0)] = H[ω^ω^2] ≒ F[ω^2](n)
H[((((0)0)0)0)] = H[ω^ω^ω] ≒ F[ω^ω](n)

>>348
× "((0)000)" => C0(C0(0),0,0,0,0) => Γ_0
○ "((0)000)" => C0(C0(0),0,0,0) => Γ_0

ミスが多くてすいません。

Seq の定義は、定義式の数を減らすため、>>347 の定義と微妙に変えてあります。

>>350
> Seq の定義は、定義式の数を減らすため、>>347 の定義と微妙に変えてあります。

C0(Ｘ, B, □, a) = lim { 初項 a / 2項目以降 C0(X, B_n, 1個前の項, □) }

といった感じですか？

どうしてこれが順序数の収束列になるのかがまだよく分かりませんが、
もう少しよく考えてみます。

>>336
F_ω^ω(x)はx重帰納的関数に相当するとたいていのHardy functionに
関する論文には書いてあるようです。x重帰納的関数は詳しくは知りませんが
たしか前スレにそれらしいものが載ってたと思います。

このようなこともあってF_ε_0(x)に相当する関数を順序数なしで定義するのは
不可能だと思っていたのですがふぃっしゅ数ver5がそれに到達している
というのは本当でしょうか？
Snakeやver5はまだ理解していないので理解できたらそれらとHardyの比較も
やりたいと思っています。

>>352
ふぃっしゅ数ver5がF[ε_0](n)に達しているかどうかは、
よく分かりません。>>292では、達しているとされていますが、
その計算内容が十分にまだ分かっていません。

「F[ω^ω](x)はx重帰納的関数に相当する」ということから
「F[ε_0](x)に相当する関数を順序数なしで定義するのは不可能」
という帰結になるのはなぜでしょうか？「x重帰納的関数よりも
大きな関数は順序数なしでは定義できない」というようなことでも
あるのでしょうか？

「定義できない」ということが、もしも「TMで構成できない」と
いうことになればF[ε_0](x)がBB級の大きさになる可能性もありますが、
そんなことはないですよね。Hardy関数が計算可能である、という
ことに関しては特に問題ないようですし。

逆に、F[ε_0](x)等のHardy関数をTMで構成できるのであれば、
それはつまり帰納的に定義できるという意味だと感じますが、
甘いでしょうか。

Provably recursive という言葉も出てきましたが、そのあたりの
言葉との関係でしょうか…。

ふぃっしゅ氏キテター
>>352
よく考えたら順序数と対応付けられる集合とかリストとかを
しらみつぶしに禁止するつもりですか？
Peano Arithmeticの中では任意のm(x)を構成することが
不可能ってことになるんじゃないでしょうか。

新参者です。最近このスレを知った物で。
僕が前から考えていた巨大数の表記方法を失礼ながら書かせてもらいます。
Ａ〜・Ｂという表記をするんですが、（〜・で一つの記号です）定義として
Ａ〜・1＝Ａ
Ａ〜・2＝Ａ＾Ａ
Ａ〜・3＝Ａ↑↑Ａ
Ａ〜・4＝Ａ→→Ａ
としています。つまり、〜・の後の数字が一つ増えるごとに→→と同じこと
前の記号に行うという事です。
次にＡ〜・〜・Ｂ＝Ａ〜・（Ａ〜・Ｂ）と定義します。
次にａｂｃｄの自然数において
ｎ＝ａ〜・ｂ＞（ａ＾ｂ）〜・（ｃ＾ｄ）＞ｂ＞ｄ＞ｃ＞ａ
が成り立つ時のｎの最小数を◎と表示します。
〜・だとふた文字に見えるので♪を代用します。
◎♪♪♪♪♪♪♪♪◎という表記は10文字以内では大きい表示になるんでしょうか？

定義を含め10文字にしなきゃいかんがな。

>>355一番大切な事書くの忘れてました。
Ａ〜・Ｂの表記のＢは何種類目の記号が使われたかを表しています。
Ｂ＝100なら100種類目の記号という意味です。巨大数を表す場合、
なんらかの記号を使って標記すので、最終的にはその記号の数を数える
のが最も大きな数になるという考えから〜・を考案したのです。
ただこのままだと、ほとんど反則なので＞＞355では一番解りやすい
→→の法則で次の記号を定義しました。（もともとＡ〜・Ｂは絶対
に表記出来ない数がある事の証明で作ったので、Ｂ＝100なら100種類
の記号を必ず使います）　　説明下手ですいません。
あと途中の式ですが、これは
ａｂｃｄの自然数において
ｎ＝ａ→→ｂ＞（ａ＾ｂ）→→（ｃ＾ｄ）＞ｂ＞ｄ＞ｃ＞ａ
が成り立つ時のｎは少なくとも3→→1025より大きい数のとき
であるの応用で作りました（ｎの最小値がいくらは、僕にわ
解らないです。誰か計算できるひといませんかね）

ちなみに、>>338 のプログラムでは、F[ε_0](n)を超える
F[φ_ω(0)](n)やF[ψ(Ω^(Ω+ω))](n)がいとも簡単にコーディング
されていますが、このプログラムを理解できる人はいますか？

おそらく、基本的には>>347のアイデアを使っているのだと
思います。私としては、順序数の収束列をこのように多重帰納
関数の様な形で定義できる、ということが驚きで、いまだ理解に
至っていないのですが…。

http://web.mit.edu/dmytro/www/other/OrdinalNotation.htm

こちらのページを見ても、C(Ｘ, B, □, a)を導く一般式、のような
ものは書かれていないように見えますし。やはり、なぜ>>347の
式で順序数の収束列を定義できるか、という点については解説
していただかないと、私だけではなく皆さん理解できないのでは
ないでしょうか？

ふぃっしゅ数の大きさについては、
http://www.geocities.co.jp/Technopolis/9946/log/ln051.html
ここの58で、m(3)がF(x,y,z)=F(x-1,F(x,y-1,z),F(x,y-1,z)) で
あらわされました。この関数が真の三重帰納か、それとも実は
二重帰納か、という議論があったとは思いますが、いずれにしても、
m(n)は良くて多重帰納、もしかすると二重帰納になる気がします。
F[ε_0](n)になるというのは、落ち着いて考えると過大評価しすぎ
なような…。

また、m(3)が三重帰納であれば、s(n)はm(3)で生成される程度の
関数ですから、それよりも小さく、二重帰納程度です。

そうすると、チェーンはs(2)程度、チェーン回転、バードはs(3)程度
であることが分かっているので、いずれも二重帰納で、
m(n)が多重帰納であるとすれば、

Knuthの上矢印 3(↑^n)3 ≒ F[ω](n)
Ak(n, 3) ≒ F[ω](n)
ふぃっしゅ数バージョン1のSS変換：F[ω^2](n)
n個のnからなるConwayのチェーン ≒ F[ω^2](n)
ふぃっしゅ数バージョン2のSS変換：F[ω^2](n)
チェーンの回転 ↑n (3,3,3) ≒ F[ω^2](n)
バード数の定義の X_n(a) の入れ子操作n回 ≒ F[ω^2](n)
ふぃっしゅ数バージョン3のs(n)変換：F[ω^2](n)
ふぃっしゅ数バージョン５のm(3) ≒ F[ω^3](n)
真の三重帰納関数 ≒ F[ω^3](n)
例: A(x+1,y+1,z+1) = A(x,A(x+1,y,A(x+1,y+1,z)),A(x+1,y+1,z)))
真の四重帰納関数 ≒ F[ω^4](n)
例: A(w+1,x+1,y+1,z+1)=
　A(w,A(w+1,x,A(w+1,x+1,y,A(w+1,x+1,y+1,z)),A(w+1,x+1,y+1,z)),A(w+1,x+1,y,A(w+1,x+1,y+1,z)),A(w+1,x+1,y+1,z))
真のn重帰納関数 ≒ F[ω^ω](n)
ふぃっしゅ数バージョン５のf5(n) ≒ F[ω^ω](n)

こんな感じになるのではないでしょうか。

もし、m(n)が二重帰納だよ、ということになれば、>>360で
真の○重帰納関数以外は、すべてF[ω^2](n)でした、という話に
なると思います。

>>311が正しいのか、それとも本当は>>360のような感じなのか。
そして、それはHardy関数を正確に計算することではっきりする
ものなのか。

Hardy で関数の大きさが整理できるといっても、正確に計算
しようとするとけっこう大変ですね。

さてさて、順序数の議論は高度でなかなかついていけずにいますが、
議論の雰囲気を読むと、Hardy + 順序数による巨大数の定義は、
canonical sequence の取り方が１つに保証されないε_0以上の
世界は、関数が１つに定まるかどうか不明という点で、きっちりと
定義された関数、あるいは数の仲間入りをさせていいかどうかと
いう疑問がまだ残っています。

そんなこんなで色々と昔を思い出していると、やはり多重帰納は
強力なので、なんとかして多重帰納を本質的に強める方法はないか、
と考えてしまうわけですが…。

http://www.geocities.co.jp/Technopolis/9946/log/ln051.html
ここの184によって、n重帰納関数 A_n(a_n,...,a_1) を定義する。
ただし、A_1(x)=f(x)、g(x)=A_x(a_x,...,a_1)とすることで、
関数 f(x) から 関数 g(x) への写像が定義される。
この写像は、f(x)=x+1という関数をF[ω^ω]クラスに持って行く
だけの力を持った写像である。

この時に、生成された多重帰納関数に対してこの写像の適用を
繰り返すとどうなるか。

>>362
(1) F[ω^ω] のまま変わらない
(2) F[ω^(ω+1)], F[ω^(ω+2)], ... F[ω^(ω*2)]
(3) F[ω^(ω*2)], F[ω^(ω*3)], ... F[ω^(ω^2)]
(4) F[ω^(ω^2)], F[ω^(ω^3)], ... F[ω^ω^ω]
(5) F[ω^ω], F[ω^ω^ω)], ... F[ε_0]

良くて(3)あたりだと思うのですが…どうでしょう。

この写像をM2変換としたふぃっしゅ数V5を考えたところで、
F[ε_0] までは到底到達しない…のでしょうね。本質的に強める
ためには、更なる工夫が必要かな。

>>362
> ただし、A_1(x)=f(x)、g(x)=A_x(a_x,...,a_1)とすることで、

ただし、A_1(x)=f(x)、g(x)=A_x(x,x,...,x)とすることで、

でした。

>>353
すいません、書き方がまずかったです。
Hardy Functionはもちろん計算可能ですのでもちろんF[ε_0](x)はBB以下になります。
単にPAではProvably recursiveでない最小のものということですね。
過去スレに（一般的な？）多重帰納関数の例がでてきたときに順序数なしでは
これが最強だと思っていたのでF[ε_0](x)レベルのものは無理なんじゃないかと
勝手に思っていたので、ふぃっしゅ関数ver5がこれに至っているということに懐疑的に
なっていました。
しかし、ふぃっしゅ関数ver5がF[ω^ω](x)（＝H[ω^ω^ω](x)）に至っているというだけ
でも個人的にはすごいことだと思います。

>>362
＞ε_0以上の世界は、関数が１つに定まるかどうか不明
http://www.geocities.co.jp/Technopolis/9946/log/thread6.html
ここの>>655に定義の例が書かれています。

√(36)=6

http://www.geocities.co.jp/Technopolis/9946/log/ln051.html
このスレッドを読み直しているところですが、ふぃっしゅ数バージョン５
(F5)は多重帰納関数以上、ということでどうやら良さそうです。

まず、58の式はm(3)1回で生成されるs(1)に相当するm(2)がアッカーマン
であることを示している式です。それは当たり前のことで、
>>359のようにm(n)が二重帰納ということにはならないわけですが、
そのあたりで本人が錯誤をしていました。

m(n)の威力はm(3)からではなくm(4)からはじまりますが、
m(4)の計算をした63を見ただけでは、まだ2重帰納か多重帰納かは
よく分からない。

そこでまず、3重帰納の定義は、76,155,182をまとめて

3重帰納関数
f(x+1,y+1,z+1) = f(x,f(x+1,y,f(x+1,y+1,z)),f(x+1,y+1,z)))
が3重帰納である所以は、
f(x+1,y+1,z+1) が 3-term でそのなかに現われる f は
f(x,*,*), f(x+1,y,*), f(x+1,y+1,z) という形であり、
ただし、f(0,y,z) はこの定義で 2-term の形で定義される。

ということです。ここで、f(x,*,*), f(x+1,y,*), f(x+1,y+1,z) とは
(1) f(x,*,*) の * に f(x+1,y,*) を入れる
　→ f(x,f(x+1,y,*),f(x+1,y,*))
(2) この式の * に f(x+1,y+1,z) を入れる
　→ f(x,f(x+1,y,f(x+1,y+1,z)),f(x+1,y+1,z)))

という意味です。

これがなぜ、どの2重帰納よりも大きい3重帰納となるか。
それは、157に書かれている通り、
f(x,*,*), f(x+1,y,*), f(x+1,y+1,z) からxを落とすと
f(y,*), f(y+1,z) 、すなわち f(y, f(y+1,z)) の2重帰納が出てくる。
つまり、f(x,y,z) は、xを1つ増加させる毎に、y,zに関する
2重帰納をしている。したがって、2重帰納を有限回(n回)施して
得られるどんな2重帰納関数よりも、x>nの時点で大きくなるが
ために、3重帰納関数はいかなる2重帰納関数よりも大きくなります。

これは、アッカーマン関数がいかなる原始帰納関数よりも大きい
ことの説明と同じで、アッカーマン関数が原始帰納関数を枚挙
するがごとく、3重帰納関数が2重帰納関数を「枚挙している」
ということです。

Hardy 関数では、2重帰納の操作 ω^2 を枚挙することで、
ω^2, ω^2+ω^2, ω^2+ω^2+ω^2, ..., ω^3
の収束列が得られる、ということに相当するのでしょう。

さて、ここで多重帰納の本質を理解する必要があります。
そこで、あらためて自分が書いた 146-147 を読み直してみると、
どうやらそんなに間違ったことを書いてないです。

s(2)が2重帰納である、というところまでは良しとして
(F5のs(n)はF3のs(n-1)に相当する)、この説明の中でキーと
なるのは、「s(3)が2重帰納の操作を荒い意味で枚挙する」
という表現です。

s(3)の定義は
s(3)f(x)=(s(2)^x)f(x)
となりますが、
s2(n,x)=(s(2)^n)f(x)
と書いた時に、s(2)は2重帰納の操作をあらわしているので、
2重帰帰納をm回施して得られるどんな2重帰納関数よりも、
n>mの時点で大きくなります。このように、s2(x,x)は
2重帰納を枚挙する3重帰納となります。
したがって、s(3)は3重帰納の操作となります。

そうすると、s(n)は同様にn重帰納となります。

いやはや、皆様（分かる人には）分かっていたことを、
ようやくもって本人が理解できた、というところでしょうか。

>>367->>369の考察により、>>360は撤回します。

>>311の前半にふぃっしゅ数Fを加えて

Knuthの上矢印 3(↑^n)3 ≒ F[ω](n)
Ak(n, 3) ≒ F[ω](n)
n個のnからなるConwayのチェーン ≒ F[ω^2](n)
F5のm(2)n回 ≒ F5のs(1)n回 ≒ F[ω^2](n)
チェーンの回転 ↑n (3,3,3) ≒ F[ω^3](n)
F5のs(2)n回 ≒ F3のs(1)n回 ≒ F1,F2のS変換n回 ≒ F[ω^3](n)
バード数の定義の X_n(a) の入れ子操作n回 ≒ F[ω^3+ω+1](n)
F5のs(3)n回 ≒ F3のs(2)n回 ≒ F2のSS変換n回 ≒ F[ω^4](n)
5変数Ak ≒ F[ω^4](n)
多変数Ak Ak(n個のn) ≒ F[ω^ω](n)
F5のs(n) ≒ F3のs(n) ≒ F[ω^ω](n)
F5のm(4) = F5のm(3)n回 ≒ F[ω^ω](n)

ここまでは理解できました。

>>311の後半は、まだ理解できていません。

ふぃっしゅ数考案者の希望的観測としては、>>292のように

Ak を２重リストに拡張、Ak([n個のn], [n]) ≒ F[ω^ω^ω](n)
F5のm(5) ≒ F[ω^ω^ω](n)
F5のm(6) ≒ F[ω^ω^ω^ω](n)
F5のf5(n) ≒ F[ε_0](n)

となればいいかな、と思いますが、はたしてそうなるかどうか。
考案した本人も、その大きさを評価できずにいます。

>>365
なるほど。スレッド6の655におけるα<Γ_0 が φ_β(γ) (β,γ<α)の
定義を見ると、このような形できれいに記述できるのであれば、
>>347-350のように順序数の定義を帰納的に記述できて、
http://web.mit.edu/dmytro/www/other/OrdinalNotation.htm
ここのordinal, stronger ordinal といった表現を簡潔に与える
ことができるとしても、不思議はないような気がしてきました。

とはいえ、>>338のプログラムを見ると、本当にこんなに短い
プログラムでF[ψ(Ω^(Ω+ω))](n) を生成できるのかと、驚くばかり
ですが。それが、計算可能の意味するところといえばそうですね。

稚拙な質問で申し訳ないですが・・
ＢＢ関数の定義が計算出来るどんな関数より大きな関数という事
らしんですが。無限大に増加する関数以外は全て計算出来る関数
だとしたＢＢ関数は存在しない関数、もしくは大きい事が証明出
来ない関数になると思うんですが。
実際のところＢＢ関数はそこらへんの事はどうｸﾘｱｰしてるんですか？

>>374
> 無限大に増加する関数以外は全て計算出来る関数
無限大に増加する関数y=xは計算できます。
「ある値を代入したときに無限大になる」という
意味でしょうか？だとしたら、BB関数の値は有限
ですが有限時間内に計算できません。

> ＢＢ関数は存在しない関数
BB関数は存在します。しかし、その値を有限時間内に
計算ができません。

> 大きい事が証明出来ない関数
「あらゆる計算可能な関数よりも大きい」という
「大きい事」に関しては、証明ができます。
「どのくらい大きいか」を具体的に計算は出来ません。

さて、

自分の中で、曖昧だった多重帰納の概念がようやくはっきり
したので、これまでのまとめの文章を作ろうと考えていますが、
しっかり作るとかなりの大作になりそう…。

その次の段階ですが、ハーディーを使って、バージョン5よりも
大きな関数がどんどん構成されるようになってきたので、
いよいよバージョン6を考えてみようかという気にもなって
きました。ふぃっしゅ数の特徴である高階集合の定義で、
ハーディーでいうところのどのあたりまで到達できるだ
ろうか、というのが目標です。

>>375　解答ありがとうございます。
無限大に増加する関数とは、例えばｆ（0）＝0　Ｆ（1）＝1　ｆ（2）＝∞
という意味で書きました。極端にすればｆ（0）＝0　ｆ（極限に小さい数）＝∞
僕的には∞＝∞＾∞＝∞↑↑∞と考え、∞になるものは大小の比較は出来ないと
考えていたもので。
ＢＢ関数の定義は有限時間で計算すると理解します（あと、人間の能力で
も入るかもしれませんが）

ＢＢ関数の定義は、有限時間内で計算できない定義です。
ただし、定義によって有限の数が定まる事が保証されています。
人間の能力は無関係です。

ここから先は、BBの定義そのものを理解しないとどうしようも
ないといえばないのですが、たとえばBB(10)を計算したいとします。
定義にしたがって計算すると、BB(10)の値となる候補が次々と
計算されます。その候補の値は、計算時間がたてばたつほど
大きくなります。真の値BB(10)は必ず存在しますので、
その値に到達する時も来るでしょう。ただ、その計算された値が
BB(10)であるという保証が出ません。保証が出ないという事は、
計算が終了しないということです。計算時間が増えるにつれて、
どんどん候補の値が大きくなるけれど、どこで「本当のBB(10)」
に到達したかを知り得ることができないので、有限時間内に
計算が終了しない、つまり計算できない、ということになります。

いまさらなんですが、ふぃっしゅ数ver.5の最終的な定義はどれなんでしょうか？
過去スレを見ても何度も変更されているし、途中で話がそれてしまっていて
わからないのですが・・・

>>377
ＢＢ関数が存在するという事は今の所理解出来ませんが、僕がＢＢ関数を
理解してないという事は理解しました。（ＢＢ関数の公式てあるのかな？）
ちなみに＞＞376の様になる関数には
Ｙ＝Ｎ＾∞や　Ｙ＝Ｎ＾Ｙ（Ｎ≠1なら単に成り立たないともいえるが）
が有ります。
あと、ふぃっしゅ数については、僕はまだ理解していませんが、存在して
いる事はわかります。

>>378
そうですね、まずはふぃっしゅ数ver.5の定義をはっきりさせる
ところからはじめようと思います。おおまかな原案は書きましたが、
きちんとこれが定義だという形にはまだしていなかったので。
ちょうどその頃に、色々な議論があってうやむやになってしまって
いました。

>>379
BB関数は、計算理論の勉強をしないと理解できません。
計算理論の専門書を読んで理解するのが、一番いいのだと思います。
私は、英語のホームページを読んで理解しましたが、日本語の
ホームページで分かりやすく解説してあるところは、はたして
あるかどうか。

BBを英語で理解するとすれば、たとえばWikipediaですが
http://en.wikipedia.org/wiki/Busy_beaver

ここの2-state S(n,m)の値を見ると、

BB(2) = 6
BB(3) = 21
BB(4) = 107
BB(5) ≥ 47,176,870
BB(6) ≥ 3.0 x 10^1730

となっています。BB(4)までは「=」で、正確な値が分かって
います。BB(5)以降は「≥」となっています。つまり、
BB(5)の値は47,176,870 かもしれないし、それよりも
大きいかもしれない。

我々は、まだBB(5)の正確な値を知り得ていない、という
ことになります。BB(6)の正確な値は、どんなに計算機の
速度が向上しても、どんなに長い年月をかけても
（たとえばふぃっしゅ数年とか）、計算できないでしょう。

今までの話の流れだとBB(n)はS(n,m)ではなくてΣ(n,m)の
方でしたね。訂正しておきます。

BB(2) = 4
BB(3) = 6
BB(4) = 13
BB(5) ≥ 4098
BB(6) ≥ 1.2 x 10^865

ＢＢ関数がなんとなくですが解ってきました。とりあえず計算理論の勉強からします。
丁寧な解答ありがとうございます。

計算可能な関数とは、>>260 のようなプログラムで書ける関数のこと。
ビジービーバー関数とは、プログラムn文字で作り出せる最大の数。（※）
だからプログラムで書けるどんな関数よりも増大度が大きい。

※実際はBBはチューリングマシンという非常に単純なマシンでの定義となる

ただ、
すべての値に対してBB(n)を返すプログラムがかけないというだけであって、
BB(10)やBB(100)を返すプログラムの存在を否定するものではない。

>>351
微妙にちがう。初項は a+1。

----- >>338 のプログラムの解説 ------
>>266 のプログラムを色々変えて小さくしたもの。

117語のものは、C0の変数を３つに限定し、一番左のは整数に限定したもので順序数を作り出している
132語のものは、C0を多変数のまま使っている。
（コメントに F[ψ(Ω^(Ω+ω))](n) と書いてあるのはF[ψ(Ω^ω)](n) の間違い）

プログラムでは F[ψ(Ω^ω)](9) 程度の数を返すが、
プログラム上の数値のいくつかを変えることで 9 を大きく出来る。

○小さくする工夫
φよりも定義が簡単で加算の定義も不要なC0を用いている
ハーディー関数を再帰ではなくループで表現している
F[ψ(Ω^ω)](9) = F[ψ(Ω^9)](9) なので、F[ψ(Ω^9)](9) を計算している
収束列を微妙に変えている
C言語上の色々な工夫でサイズを小さくしている
など

>>363
F[ω^ω*2], F[ω^ω*3], ... F[ω^(ω+1)]

>>372
ふぃっしゅ数V5のm(5)の大きさは力ずくでもわかる。

（m(2) = m2, m(3) = m3, m(4) = m4, ...）
aは自然数

m2 ===> +1　　 （f ≒ F[a] の時、 m2 f ≒ F[a+1] という意味）
m2 m2 ===> +2　　（f ≒ F[a] の時、 m2 f ≒ F[a+2] という意味）
m2^a ===> +a
m3 m2 ===> +ω
m3 m2 m3 m2 ===> +ω*2
m3 m2 m3 m2 m3 m2 ===> +ω*3
(m3 m2)^a ===> ω*a
m3 m3 m2 ===> ω^2
m3 m3 m3 m2 ===> ω^3
m3^a m2 ===> ω^a
m4 m3 m2 ===> ω^ω
m3 m4 m3 m2 ===> ω^ω*ω
m3 m3 m4 m3 m2 ===> ω^ω*ω^2
m3^a m4 m3 m2 ===> ω^ω*ω^a
m4 m3 m4 m3 m2 ===> ω^(ω*2)
(m4 m3)^a m2 ===> ω^(ω*a)
(m4 m3)^a m2 ===> ω^(ω*a)
m4 m4 m3 m2 ===> ω^ω^2

(m4 m3)^a m2 ===> ω^(ω*a)
(m4 m3)^a m2 ===> ω^(ω*a)
m4 m4 m3 m2 ===> ω^ω^2
m3 m4 m4 m3 m2 ===> ω＾(ω^2+1)
m3^a m4 m4 m3 m2 ===> ω^(ω^2+a)
m4 m3 m4 m4 m3 m2 ===> ω^(ω^2+ω)
m4 m4 m3 m4 m4 m3 m2 ===> ω^(ω^2*2)
(m4 m4 m3)^a m2 ===> ω^(ω^2*a)
m4 m4 m4 m3 m2 ===> ω^ω^3
m4^a m3 m2 ===> ω^ω^a
m5 m4 m3 m2 ===> ω^ω^ω

http://web.mit.edu/dmytro/www/other/OrdinalNotation.htm
ここのたろう的理解です。

●C0
[A General Notation] のCのΩ導入前を多変数化

C0(..., a5, a4, a3, a2, a1, a0) = C(..., Ω^4 * a5 + Ω^3 * a4 + Ω^2 * a3 + Ω * a2 + a1, a0)
C0(..., a4, a3, a2, 0, 0) = φ(..., a4, a3, a2, 0)

>>190 のψ(Ω^ω) 未満の順序数をすべて表現可能。

●C1
[An Ordinal NOtation] の多変数化

C1(1,0,0) を、帰納的でない最小の順序数、
C1(2,0,0) を、C1(1,0,0) と帰納的定義で表現できない最小の順序数、
......
C1(1,0,0,0) を、C1(a2, 0, 0) と帰納的定義で表現できない最小の順序数、
....
というような解釈で良いかと。

C1([C1で生成される順序数], 0) は帰納的な順序数となる。

C1(1,0,0) は 上のΩや >>190 のΩとほぼ同じ意味。
C1(C1(1,0,0),0) = C0(1,0,0)
C1(C1(1,0,0)^2,0) = C0(1,0,0,0)
C1(C1(1,0,0)^3,0) = C0(1,0,0,0,0)

>>202 のψ_a(0) が C1(a,0,0) とほぼ同じ意味。
３変数で >>202 の ψ_0(Ψ) 未満の順序数をすべて表現可能。

●C2
[Beyond Second Order Arithmetic] の C の多変数化

C0 => C1 の進化を繰り返したもの。

C2(C2(1,0,0),0) = C1(1,0,0)
C2(C2(1,0,0)^2,0) = C1(1,0,0,0)
C2(C2(1,0,0)^3,0) = C1(1,0,0,0,0)

C2([C2で作り出す順序数], 0) はC1でつくり出せる順序数となり、
C2(C2([C2で作り出す順序数], 0)) で帰納的な順序数となる。

C0 の収束列は >>347 で定義。
多変数veblen ＋ 加算 と同等の表現が可能。

C1 の収束列は、>>202 のような方法で定義できる。
だいたい８個くらいに場合分けした定義となる。
３変数で、veblen ＋ 添字付ψ ＋ 加算 と同等の表現か可能。
プログラムで書けば、>>266よりずいぶん小さくできそう。

C2 の収束列はかなり複雑で途中で挫折。

C3, C4.... と拡張できそうな気がする。
さらには、C_n(c, b, a) ==> C_[順序数](c, b, a) ==> C(d, c, b, a) => 多変数化 => さらに大きなΩでの表現 => ...

でも、順序数の専門家がもっと大きな帰納的順序数を見つけてそう。

>>390
> C2([C2で作り出す順序数], 0) はC1でつくり出せる順序数となり、
ここは間違いで、以下に訂正。

C2([C2で作り出す順序数], 0) はC2(1,0,0) 未満の順序数となり、

>>355
定義がよくわからないけど
◎ = 2♪(3^4+2) かな？

>>389-392
その定義を見ていると、ナゴヤ数(スレッド6の510-511)も
どこかのクラスに入りそうですね。

まだ、雰囲気だけしかつかめませんが。

>>390
まだまちがってた。

C2([C2で作り出す順序数], 0) はC2(1,0,0) 未満の順序数となり、
C2(C2([C2で作り出す順序数], 0),0) で帰納的な順序数となる。

>>394
>>135 が正しければ大きさは、
多変数veblenの極限 = ψ(Ω^ω) = C0の極限 = C1(C1(1,0,0)^ω, 0) 程度

>>125 のveblenの極限はψ(Ω^Ω) = C1(C1(1,0,0)^C1(1,0,0), 0)
同じように拡張していきn重リストにするとその極限は、ψ(ε_(Ω+1)) となって
Howard ordinal に到達。

ふぃっしゅ数バージョン5 (F5) の定義

[1] 集合Mn (n=0,1,2,...)を以下のように定める。
M0=自然数の集合
M{n+1}=写像Mn→Mn全体の集合
Mnの元をMn変換と呼ぶ

[2] Mn変換 m(n) (n≧1) を以下のように定める。
f_n∈M(n)に対して、m(n+1)(f_n)=g_nを以下で定める。
　f_{n-1}∈M(n-1)に対して、g_n(f_{n-1})=g_{n-1}を以下で定める。
　　f_{n-2}∈M(n-2)に対して、g_{n-1}(f_{n-2})=g_{n-2}を以下で定める。
　　　……
　　　f_0∈M(0)に対して、g_1(f_0)=g_0を以下で定める。
　　　　g_0=(..((f_n^{f_0}f_{n-1})f_{n-2})...f_1)f_0

すなわち
m(1)(f_0)=f_0^f_0
(m(2)f_1)f_0=(f_1^f_0)(f_0)
(..((m(n+1)f_n)f_{n-1})...f_1)f_0:=(..(f_n^{f_0}f_{n-1})...f_1)f_0

[3] ふぃっしゅ関数 F5(x) を以下のように定める。
　F5(x):=((..((m(x)m(x-1))m(x-2))...m(2))m(1))(x)

[4] ふぃっしゅ数 F5:=F5^63(3) とする。

>>393
僕の作った式に解答ありがとうございます。
〜・Ｎの定義はＮ×Ｎ＜Ｎ〜Ｎ＜Ｎ↑↑ＮならＮが増える毎に表記方法も上位の物を使用して
行く関数を作れば大きな関数を作れると考えて作りました。
よく考えればＮ＾ＮからＮ↑↑Ｎへ変化するのとＮ↑↑ＮからＮ→→Ｎに変化するのは
意味が違うため関数としてはなりたったなかったですね。
考えてる途中にＮ＝1なら1　Ｎ＝2なら22　Ｎ＝3なら333×333　Ｎ＝4なら4444＾4444
にしないといけないかと思ったくらいですから。
（見た目が面白いので1.22.333となる関数を作ろうとしているんですが上手くいかないですね。）
◎を導く式のほうは、大きくなる関数を作る事を、ある巨大数を入れないと成り立たない式を作る
ことで抜けないか考えて挫折したときの残骸です。＞＞357の→の方が実際に作っやつですが。
それでもＡ→→ＢにおいてＢの数が大きいほうがＡの数が大きいときより大きな数になる事を
証明できれる最小の数であれば、グラハム数や現在最も大きい素数2＾32582657-1の様に
意味のある数として使えるかなと思い使いました。これもよく考えてみれば
Ｎ＝Ａ→→Ｂ＞Ｂ→→Ａ＞Ｂ＞Ａ
と書いた方が適切でしたね。
さらにＮ＝3→→4＞4→→3が成り立つことを正確に計算できても、グラハム数＞4→→3
が計算されたらグラハム数より大きい意味のある数にはならないですよね。
3→→4＞グラハム数は当たり前ですから。
もし↓や←を使った場合の計算が膨大すぎて、現在まだ正確な計算が出来ていないなら、
正確に計算することに意味が出てくるんでしょうが。
Ｎ＝Ａ＾Ｂ＞Ｂ＾Ａ＞Ｂ＞ＡならＮの最小値は32
Ｎ＝Ａ↑↑Ｂ＞Ｂ↑↑Ａ＞Ｂ＞ＡならＮの最小値は16
なら僕にも計算できるんですけどね。
僕の様な素人の書き込みでも、大きな数を見つけるヒントでも転がってれば良いんですが。

今となってはとても小さい数であるF1やF2あたりから見直しています。

それで気づいたのですが、今まではふぃっしゅ関数バージョン1 F1(x)
が2重帰納かと思っていましたが、違いました。3重帰納です。
F1(x) ≒ F[ω^3](x) (3重帰納)
なぜかというと、F1(x)は2重帰納のS変換を繰り返す回数が変数のx以上に
なるので、S変換をちゃんと数え上げているんですね。

一方、F2(x)は3重帰納のSS変換を63回繰り返しているので、
F2(x) ≒ F[63*ω^3](x) (3重帰納)
となります。F1(x)もF2(x)も、同じ3重帰納のクラスで、チェーンよりも
強くバードと同じ程度でした。

今まで、F1(x)の強さを過小評価していたようです。

２重帰納 ≒ F[ω](n)
３重帰納 ≒ F[ω^2](n)
じゃないの？

F1(x), F2(x) の定義はどこにありますか？

http://www.geocities.co.jp/Technopolis/9946/log/ln023.html

ここの >>320 で定義されているふぃっしゅ関数が F2(x) だとすると、
F2(x) ≒ F[ω*大きな整数](x) な気がする。
f(x) = x+1 に対してS変換を整数回行う操作を63回繰り返すだけですよね？

ええと、>>398は大きな勘違いでした。
F1(x)は2重帰納です。

>>399
そうでした。
F1(x) ≒ F[ω*大きな整数](x)
F1(x) ≒ F[ω^2*63](x)
です。

>>400
そちらはF1(x)の定義です。
F2(x)の定義は
http://www.geocities.co.jp/Technopolis/9946/log/ln032.html#R47
ここにありますが、F1(x)のSS変換の定義において、
S変換をx回繰り返すものです。

訂正

F1(x) ≒ F[ω*大きな整数](x)
F2(x) ≒ F[ω^2*63](x)

3変数アッカーマン関数
A(x+1,y+1,z+1) = A(x,A(x+1,y,A(x+1,y+1,z)),A(x+1,y+1,z)))
が3重帰納 F[ω^2] であることの証明

A(x+1,y+1,z) からAへの代入(合成)2回で A(x+1,y+1,z+1)ができる
→ zに+1する操作は合成の操作

Z=A(x+1,y+1,z)-a (Z > z+1) とすると、
f=A(x+1,y,Z) からg=A(x+1,y+1,Z)を合成と原始帰納で生成できる。
(1) Zをa増やす → A(x+1,y,A(x+1,y+1,z))
(2) A(x,y,A(x+1,y+1,z))のyに代入 → A(x+1,y+1,z+1)
(3) zをZ-(z+1)増やす (zを増やす操作を数え上げるので原始帰納)
したがって、yに+1するのは原始帰納

Y=A(x+1,y,Z)-bとすると、
f=A(x,Y,Z)からg=A(x+1,Y,Z)を3番目の引数を増やす原始帰納と
2番目の引数を増やす2重帰納で生成できるので、xへの+1は2重帰納

A(x,y,z)はxへの+1を数え上げるので3重帰納

大野菜協会、長期間の研究の末「３ｍの巨大サツマイモ」の栽培に成功。しかし、ちんこに似ていたため非公開に。【画像あり】

日本大野菜協会が2002年に特別チームを発足し、5年の歳月を費やし、3ｍもの巨大サツマイモの栽培に成功した。
しかし、それが一般に発表される事はなかった。
その理由は栽培された巨大サツマイモがあまりにも男性器に酷似していたためである。
大野菜協会会長は「5年の歳月と沢山の経費をかけて作り出した大作といえるものだし、一般の方々にも見てもらいたい…が、ここまで酷似していてはコレを発表することは出来ない。我々にも恥がある。」
と、肩を落として語った。
長い歳月に渡り研究に研究を重ね、苦労の末栽培された世紀の大サツマイモは性器に似た大サツマイモになるという悲しい結末で幕を閉じた。

http://society6.2ch.net/test/read.cgi/river/1188899832/

>>403
> A(x+1,y+1,z+1) = A(x,A(x+1,y,A(x+1,y+1,z)),A(x+1,y+1,z)))
3変数アッカーマン関数の定義はこれに決まってるの？
それとも、単なる拡張方法の１つ？
このスレでの合意？

単なる拡張方法の１つなら、
>>323 の方が簡単で良いと思うんだけど。

------アッカーマンの多変数への拡張の案------
●定義
　Ak(□, a) = a+1
　Ak(Ｘ, b+1, 0, □, a) = Ak(Ｘ, b, a, □, a)
　Ak(Ｘ, b+1, 0) = Ak(Ｘ, b, 1)
　Ak(Ｘ, b+1, a+1) = Ak(Ｘ, b, Ak(Ｘ, b+1, a))

　ただし、
　　a, b : 0以上の整数
　　□ : 0個以上の0
　　Ｘ : 0個以上の0以上の整数

●大きさ
　Ak(..., a2, a1, a0, n) ≒ F[...+ ω^2*a2 + ω*a1 + a0](n)
　Ak(1がn個) ≒ F[ω^ω](n)

>>405
多重帰納の定義については、
http://www.geocities.co.jp/Technopolis/9946/log/ln051.html
ここで色々議論されています。
76,77,155,181-184 あたりです。ここで提案されている
3変数アッカーマンについて検証したのが>>403で、2重帰納を
数え上げていることが分かりました。

>>323の方が簡単なので、これでω^2になっていればその方が
いいと思います。どういうしくみになっているのでしょう…。

3,4から、xを定数と見てy,zが2変数アッカーマンになっているから、
ack(x+1,y,z) = ack(x+1,0,z(y)) = ack(x,z(y),z(y))
とすると、z(y)が2重帰納関数になる。

なので、2重帰納をx回繰り返す3重帰納になる、ということか。

>>407
ちょっと書き方が変だったかな。
ack(x+1,y,z) ≒ ack(x+1,0,A(y,z)) ≒ ack(x,A(y,z),A(y,z))
といったところか。

>>405
この場合は
Ak(Ｘ, b+1, 0) = Ak(Ｘ, b, 1)
Ak(Ｘ, b+1, a+1) = Ak(Ｘ, b, Ak(Ｘ, b+1, a))
この箇所で、a0とnの計算について
Ak(..., a0, n) ≒ F[... + ω*a1 + a0](n)
という関係を作って、
Ak(Ｘ, b+1, 0, □, a) = Ak(Ｘ, b, a, □, a)
この箇所で、a=ak, b=a{k+1}として、
Ak(Ｘ, b+1, a, □, a) ≒ Ak(Ｘ, b+1, 0, □, F[ω^k])
= Ak(Ｘ, b, F[ω^k], □, F[ω^k])
≒ Ak(X, b-1, F[ω^k*2],...)
≒ Ak(X, b-2, F[ω^k*3],...)
...
≒ F[ω^(k+1)]
といった関係を作るわけですね。

ふぃっしゅしゅ氏へ質問なんですがＢＢ関数を理解するため計算理論について調べていたらμ作用素関数というのが出てきました。
（参照） http://ja.wikipedia.org/wiki/%CE%9C%E5%86%8D%E5%B8%B0%E9%96%A2%E6%95%B0

これは、
基本関数 N→→Ｎ＞Ｎ→Ｎ→Ｎ
次にバートの回転記号を○で表す
2○2＝2（2回転目←）（2回転目←）2
3○3＝3（3回転目←）（3回転目←）3
N○Ｎ＞Ｎ→→Ｎ
Ｎ○○Ｎ＞Ｎ○Ｎ○Ｎ

クラウ1 ステプ1
次に○の数を○ー○で表す（−は繋げること表しています）
2○ー○2＝2○○2
3○ー○3＝3○○○3
Ｎ○ー○ー○Ｎ＞Ｎ○ー○　○ー○Ｎ

ステプ2
次に○ー○の繋がる数を○（＝）○で表す（＝はーの本数が2本の意味です）
2○（＝）○2＝2○ー○2
3○（＝）○3＝3○ー○ー○3
Ｎ○（Ξ）○Ｎ＞Ｎ○（＝）○（＝）○Ｎ

ステプ3
次に・・

クラス2 ステプ1
クラス1のステプの数を（あ）で表す
2（あ）2＝2（＝）2
3（あ）3＝3（クラス1ステップ3の表記）3
Ｎ（い）Ｎ＞Ｎ（クラス1ステプＮの表記の（あ））Ｎ

ステプ2
（あ）から（い）の変化を（ド）で表す
（ド）の次は（レ）・・・

�@ここでクラスの数を数える記号を作ればさらに巨大な関数が作れる
�A更にステプ、クラス、（クラスを数える数）と段階が上がる事を数えると更に巨大な関数が作れる
このアルゴリズム（手順）を繰り返すことで大きな関数を作れる事が出来る。（�@�Aを関数にして・・・）

このアルゴリズムその物を関数化した物みたいなんですが。この考えで行くと

�@1帰納関数→2帰納関数→3帰納関数
�A1重帰納関数→2重帰納関数→3重帰納関数
�B1重帰納関数→2重重帰納関数→3重重重
�C�@→�A→�Bをさらに関数にする。
このアルゴリズムその物を関数にする（その方法が全然判らないんですが）と、
ふぃっしゅ数バージョン5より大きな関数になると思うんですが？
それとも、ふぃっしゅう数ではμ作用素関数は折込済みなんですかね？
（この説明で伝わると良いんですが）

・いわゆる最小化じゃん
・ふぃっしゅ数はアッカーマン関数を折込済みです

そういえばアッカーマン関数を最小化を使って表すと
どうなるんでしょう。

>>396
バージョン5の定義ありがとうございます。
自分で計算してないのですが>>387-388を見るとやっぱりF_(ε_0)(x)に到達して
そうな感じですねぇ・・・。
ヴァージョン６楽しみにしています（笑）

>>405
なるほど。おそらくその定義がn重帰納関数の最低ラインっぽいですね。
前に言われていた所謂「正規形」ってやつかもしれません。

>>411
ﾊｧ?

８ヶ月ぶりです。
ふいっしゅさんも戻って驚きです。

さて、前から放置してたナゴヤ関数について。（以後L[ω]→F[ω]に表記変更）
順序数ですが、F[F[ω](ω)]（ω）ではφ_(φ_ω)(ω)になってしまうようです。
そこで、ここで取り上げているωとは別の非加算(？)順序数Ωを使って
ωで表す順序数を変換する写像を定義できるようにします。
さらに順序数Ω以降(以後Ω_1と表記)についても同様に
その順序数(式)を変換する写像はΩ_2、Ω_3、・・・の順序数を使えばいいです。
このことを踏まえて、ナゴヤ関数Ver1.1を定義し直していきます。

それぞれの写像Fについて以下のように定義します。
F[Ω_1]：ωからなる順序数α1→β1への写像
F[Ω_2]：Ω_1、ωからなる順序数α2→β2への写像
F[Ω_n]：Ω_n-1以下からなる順序数αn→βnへの写像

F[Ω_1](λ) = F[λ](λ) (λはωで表す可算順序数)
F[Λ+n+1](λ) = F[Λ+n]^λ(λ) (ΛはΩ_1で表す順序数、^aはネスト数)
F[Λ_(Ω_1)](λ) = F[Λ_λ]（λ） (例：Λ_2 = (Ω_1)*2のとき、Λ_λ = (Ω_1)*λ)
F[F[Ω_2](Ω_1)](λ) = F[F[λ](Ω_1)]（λ）
F[Ω_n+1](Λn) = F[Λn](Λn) (Λn：Ω_nで表される順序数)

こうすれば、自然数x→可算順序数λ、可算順序数ω→別の順序数Ω_1、・・・に
置き換えたHardyFunctionやVer1のナゴヤ関数の増大度が
順序数ω、Ω_1、Ω_2へとそのまま伝わっていきます。

例えば、
F[Ω_1](ω) = F[ω](ω) ≒ φ_ω(0)
F[Ω_1](F[ω](ω)) = F[ F[ω](ω) ]（ω） ≒ φ_(φ_ω(0))(0)、
F[Ω_1+1](ω) ≒ Γ_0
F[Ω_1*2 + 1](ω)=Γ_Γ_...Γ_ω
となります。

続き。

関数の増大度について。
>>125のVebrenリスト関数と比較して、
F[Ω^2](ω) ≒ φ([2, 1][1, ω])
F[Ω^2+1](ω) ≒ φ([2, 2])
F[Ω^3](ω) ≒ φ([3, 1])
F[Ω^ω](ω) ≒ φ([ω, 1])
F[Ω^Ω + 1](ω) ≒ (λ_ω; λ_0 = ω, φ([λ_n, 1]) = λ_n+1)
（仮にφ([0, 1] [ [0,0] ])とおいてみる ）
になると推測でき、この時点で前Ver1と比べて大幅に増大するようです。
F[Ω^Ω^ ... ^Ω + 1]ではおそらく
ふぃっしゅ関数Ver5 ≒ F[ε0]
で変換元の自然数xを変換元順序数ωに置き換えたときの
増大度に匹敵すると考えられます。（多重リストVeblen関数では表記不可能か？）

F[1, 0](x) = F[F[ ... F[Ω_x](Ω_(x-1)) ... ](ω)](x)
F[n+1, 0](λn) = F[n, F[n, ... F[n, 0](Ω_λn) ... ](λ(n+1))](λn) (λnは任意Ω_nの順序数)
と置くとして、
F[1,0]以降の増大度については後で調べます。

>>409-410
基本関数 N→→Ｎ＞Ｎ→Ｎ→Ｎの計算方法がよく分かりませんが、
μ作用素を大きくする方法をうまく定義できたのでしょうか？

μ作用素そのものは計算可能関数と正確に一致するそうなので、
問題は「どうやってより大きいμ作用素を生成するか」という
ことになると思います。ふぃっしゅ数の場合は、μ作用素では
ありませんが作用素を大きくしていく、という考え方です。

F1のS変換,SS変換→2重帰納作用素の適用回数を増やす
F2のSS変換→2重帰納作用素の適用回数を数え上げて3重帰納
　作用素を作る
F3のs(1),s(2),...s(n)→n-1重作用素の適用回数を数え上げて
　n重帰納作用素を作る
F5のm(n)→「M1作用素の適用回数を数え上げるM2作用素」
　の適用回数を数え上げるM3作用素の…
　→この操作全体の回数を数え上げる

といったイメージです。

>>338 の 46580.txt と同じような考え方の関数が過去ログにありました。
5スレ目の >>768 のhydra gameです。

A{ リスト }(n) で、リストには
[[[]]]や[[][]] のような文字列が入ります。

[a] で順序数ω^a 、[a][b] のようにリストを並べたもので順序数の加算をあらわし、
A{ [[[....x個....[ ].....x個.....]]] }(x)
で F[ε_0](n) 程度の増大度になるようです。

>>396のバージョン5では、F[ε_0]=F[C0(1,0,0)]まで到達したので、
バージョン6では、F[η_0]=F[C0(2,0,0)]あたりを目標にしたいと
思いますが、順序数あるいはそれに相当する多進木のような概念を
使わずに、はたしてそこまでたどりつけるかどうか…。

とりあえず、色々と考えながら試行錯誤していきます。

>>396のようにm(1)(x)からF5(x)を生成する変換をm'(2)とします。
m'(2)は+ε_0に相当するので、>>387-388の計算でm2のところを
m'(2)におきかえれば、m2 ===> +ε_0からはじまって、
m5 m4 m3 m2 ===> ε_0*ω^ω^ω
となりそうです。だとすれば、m'(n)を

((..((m'(n)M(n-1))M(n-2))...M(2))M(1))(x)
:=((..((..((m(x)m(x-1))m(x-2))...m(n))M(n-1))...M(2)M(1))(x)

にて定義することで、m'(2)m'(1) は ε_0^2 にはなりそうです。
m(n)をm_n(0)に、m'(n)をm_n(1)に書き直すことで、
m_n(a_1,a_2,...)を定義することも可能でしょうが、まずはm'(n)の
強さを評価するところからはじめようと思います。
しかし、この様子だとm'(x)m'(x-1)...m'(1)でもε_0^ω程度という
ことになりそうで、F[η_0]まではほど遠い感じですね。

m_1(0) = x^x
m_1(1) ≒ F[ε_0]
m_1(2) ≒ F[ε_0^ω]
m_1(3) ≒ F[ε_0^(ω*2)]
m_1(1,0) := m_1(x) ≒ F[ε_0^ω^2]
m_1(1,1) ≒ F[ε_0^(ω^2+ω)]
m_1(1,2) ≒ F[ε_0^(ω^2+2ω)]
m_1(2,0) := m_1(1,x) ≒ F[ε_0^(ω^2*2)]
m_1(1,0,0) := m_1(x,0) ≒ F[ε_0^(ω^3)]
m_1(1,(0がn個)) ≒ F[ε_0^(ω^ω)]

こんなもんかな。ε_1にも到達しなさそうですね…。

とりあえず、多変数の定義があまり賢くなかったので、
そこを多変数Akを参考にしつつもう少し工夫してみる
ことにします。

ふぃっしゅさんは順序数などを使わずに挑戦ですか。
巨大数作成者同士仲間でもライバルでもいいので
お互い頑張れればいいですね。

とりあえずVer1.1のF[1,0]→F[1,1]の過程についてあげておきます。
F[1,0](x) = F[Λx](x) ( Λ(n+1) = F[Λn](Ω_(x-n-1) ),
( Λ0 = Ω_(x-1) ) (0≦n≦x, Ω_0=ωとおく)
F[1,0]^x(x) = F[F[1,0](ω)+1](x)
F[ F[1,0]^ω(ω) ](x) = F[ F[ F[1,0](Ω_1)+1 ](ω) ](x)
F[1,1](x) = F[Λx](x)
( Λ(n+1) = F[Λn](Ω_(x-n-1), Λ0 = F[1,0](Ω_(x-1)) + 1 ) (0≦n≦x)

>>411
アッカーマン関数の意味がやっと解ったです。サンクス
僕が書いたのは最小化をベースにしてアッカーマン関数作るという事だったんですね。
（この書き方で正しいか自分でも疑問だが）
>>416
毎回丁寧な解答ありがとうございます。僕的にはふぃっしゅ数のイメージが
一機に把握できますた。
Ｎ→→Ｎ＞Ｎ→Ｎ→Ｎは、4→→4のほうが4→4→4より大きいという当たり前
の事を書いただけです。（1.2.3は＝になりますが）矢印表記の場合は書き方
によって大きさが全然変わるので確認のために書きました。単純最後の大きな関数
を作るなら、3重回帰関数を作るよりＮ＝1の時1回帰関数　Ｎ＝2の時2重回帰関数
Ｎ＝3の時3重重重回帰関数になる関数を作る方が良いという理想論を書きたかった
だけなんですが（理論上は作れるはずだが、実際に作るのはかなり大変になるはず）
※バージョン6頑張ってください。

F[a](x)≒H[ω^a](x)なわけだが
+ωでも*ωでも^ωでもなくω^だってのは何気にすごい。
（単にHのやり方がのろすぎるだけともいえるが）
大きい順序数を作って入れるんじゃなく根っこのやり方を変える
ことでη_0に挑戦できないものだろうか。

逆に次は順序数の概念をとりいれたヴァージョンでも良いかと思います。
ヴァージョン４でもＢＢを取り入れているわけですし、手段を問わずに
ひたすらでかい数を追求するというのもありかと思います。
あくまで計算可能な範囲で・・・
Hardy functionをＢＢで比較できたらおもしろいんですけどね。

>>423
F[a](x)≒H[ω^a](x)ではなくF[a](x)＝H[ω^a](x)です。

F[0](x)＝H[1](x)
F[1](x)＝H[ω](x)
F[ω](x)＝H[ω^ω](x)
F[ω^ω](x)＝H[ω^ω^ω](x)
...
ですから結局、
F[ε_0](x)＜H[ε_0](x+1)
となりますから、根っこのやり方を変えるんじゃなく大きい順序数を作って入れることが
関数を本質的に大きくするのです。

ω^ε_0=ε_0なので、
F[ε_0](x)=H[ε_0](x)
です。

>424いいえイコールではありません。
>425F[ε_0](x)≒H[ε_0](x)なら知ってます。

大きい順序数を作って入れることに相当するほかの手段を
模索したいのですよ。
根っこで1行ですむような定義をしている限り+ωがせいぜい、
よってε_0を超えられない、といいたいなら私もそう思ってます。

>>425
両辺で(ε_0)_nの取り方を固定した場合、値に関してはイコールにはなりません。

>>426
＞いいえイコールではありません。
反例をお願いします。

>>427
あ、>>110の定義に基づけばイコールになるのですね。
今まで気づかなかった…
（本来Hの定義は>>70）

ε_0 = lim ω^^n とした場合、
H[ε_0](n) = H[ω^^n](n) < H[ω^^(n+1)](n) = F[ω^^n](n) = F[ε_0](n)

>>424
手段を問わないなら、

int を無限長整数としたC++言語で、
int function(int a);
という関数を作る。
10000文字以内でできるfunctionのうち増加度が最大のものの１個を考えれば、
この関数は計算可能だが増大度が非常に大きい関数となる。

関数 f と g は、
ある整数aが存在し、b>a となる全ての整数b に対し f(b) > g(b) が成り立った場合に
f > g とする。
上記の関数 f のうち、g > f となる関数 gが存在しないものを、増加度が最大であるとする。
増加度が最大のうちの１個の選び方は、
プログラムの前方からの比較で小さいものを選ぶ。

μ再帰関数でも同様の関数が作れる。
定義の中に基本関数が10000回以内出現するようなμ再帰関数の中で
増大度の最大のものを１個をえらぶ。
これも増大度の非常に大きい計算可能な関数となる。

>>424
>Hardy functionをＢＢで比較できたらおもしろいんですけどね。
>>284 で書いた通り、
H[帰納的でない最小の順序数](n) ≒ BB(n)
と言えそう。

>>424
それはそれで、ちょっと考えた事もありますが、
たとえばm(n)変換上のHardy関数を考えても順序数に
+ω^nする程度になりそうで、あまり意味のある拡張に
なりそうにないんですよね…。

まあ、あくまでも遊びなので、いろいろ考えてみようと
思います。

>>430
b>aのすべての整数に対してf(b) > g(b)であることを、
計算によって示すアルゴリズムはありますすか？

>>433
関数の具体的構成を調べるアルゴリズムが無くても、
計算可能である関数のうちの１個であることは確かなので、
計算可能である。

>>434
f>gを示すために、h=f-gとして、すべての整数b>aに対して
h(b)>0となることを示すアルゴリズムを考える。

b>aが成り立つb1,b2,...を順番に代入する「代入アルゴリズム」
では、有限の計算において常にmax(b1,b2,...,bn)=Bが存在する。
したがって、すべてのd>cに対してh(d)<0であるようなc>Bが
存在する、すなわちf<gである可能性がある。また、B以上で
h(x)が正負を無限に振動するため、fとgの大小関係を決定でき
ない可能性もある。このように、代入アルゴリズムではf>gを
有限時間内に決定できない。

では、代入アルゴリズム以外であれば決定できるのか？

f>gを有限時間内に決定できる一般的なアルゴリズムは存在
しない様に思いますがいかがでしょう。

>>435
>>433 と同様の疑問と思われます。

> f>gを有限時間内に決定できる一般的なアルゴリズムは存在
> しない様に思いますがいかがでしょう。
私は上記アルゴリズムが存在するという主張はしていません。
関数を決定するアルゴリズムが存在するかどうかに関わらず、
>>430 で定義された関数は計算可能であると思いますがいかがでしょう。
計算可能な関数から特定の１個を選んでいるので当たり前です。

----
関数を決定するアルゴリズムが存在するかどうかは今のところ私にはわかりません。
10000文字以内で出来る関数は有限個しかないので、
「10000文字以内のアルゴリズムがわかっている２つの関数の大小比較が出来ないようなものが存在するか」
という問題と同値になります。

「具体的構成を知るアルゴリズムが存在しない関数なら意味がない」というのであれば、
比較するアルゴリズムが存在する関数に限定してください。

>>436
なるほど、関数fの決定が計算可能かどうかは分からない
（問題にしない）けど、関数fは明確に定義され、計算可能
である、ということですね。了解しました。

それから、ビジービーバーを小さくするアプローチはない
ですかね。なんらかの停止判定アルゴリズムを設定して、
それによって停止しないものは停止しないとみなす、
といったような形で。そのような疑似BBは計算可能で、
計算不可能なBBよりも増大度が一気に小さくなりますが、
その小さくする幅をいかに小さくするか、という問題に
帰着させます。

結局は、停止判定アルゴリズムの計算度に依存するのかな…。

また見ないうちに楽しそうなことを…

>438
たとえば停止しない判定をステップ数で行うとしたら、
TMはステップ数以上の1を書くことはできないわけで。

TMが停止する十分条件……原始帰納的関数とかですね。
を状態遷移図から判定するアルゴリズムってできても
かなり難しそう。

>438
わざわざ小さくする意味がわかんね。

>>431
具体的な値で比較できたら面白いと思いますがそれは無理かな。
たとえば、ＢＢ（６）までなら指数関数くらいで押さえられそう
ですが、ＢＢ（８）とかだとアッカーマン関数でないと追いつかない
とか。実質、H_Ω(x)=BB(x)だとするなら、BB(20)とかBB(30)は
いったいどれくらいの大きさの可算順序数を用いたH_αが必要なのかと
・・・どうアプローチしたらいいのかわかりませんが。
ヒドラ対ヘラクレスのような単純なアルゴリズムでH_[ε_0](x)
になってしまうらしいですからやはりＢＢは人智を超えているのでしょう
ね。といろいろ想像などしています。

そのBBが基底(MIN)となる世界なんて想像できないww

BB(100)とかのチューリングマシンはタワーのような数を大きくすることを目的としたような
操作を繰り返すチューリングマシンなのか、それとも数論の答えを求めるような計算をする
チューリングマシンなのか、はたまた全く別物なのか…。

BB(4)ですらわけわからんよ。あれは急増加関数じゃなくて
たまたま0を入れたら大きな数が出てくる壊れた機械だ。

どういう計算をしてるのか、人間の能力では解釈できないようなチューリングマシンになると思う。
例えば、コラッツの予想（偶数なら2で割り、奇数なら3倍して1を足していくといつかは1になる）で
ルールは単純なのにも関わらず、いつかは1になることの理由がなかなか分からないように。
（コラッツの予想が正しいとは限らないが）

F[1,0](Ω_n)→F[1,0](F[1,0](Ω_n))について補足。

F[1,0](Ω_n) = F[ F[1,0](Ω_(n+1)) ](Ω_n)とする。
F[Ω_1](F[1,0](ω)) = F[ F[1,0](ω) ](F[1,0](ω)) = F[Λω](F[1,0](ω))
= F[ F[ ... F[Ω_x] ... ](ω) ](F[1,0](ω))

F[1,0](F[1,0](ω)) = F[ F[1,0](Ω_1) ](F[1,0](ω))
= F[ F[ ... F[Ω_(x+1)] ... ](Ω_1) ](F[1,0](ω))

Ω_ω→Ω_ω+1への定義が非常に困難なのであえて
F[1, 0](λ) = F[F ... F[Ω_ω] ... ](Ω_1)](λ)
と順序数λの形に関わらずΩ_ωに固定収束で定義しています。
この場合、F[1, 1](ω)でネスト元がF[1, 0](Ω_ω)でΩ_(ω*2)に相当します。

またHowardFunction ψ(ε_(Ω+1))については
F[Ω_1^Ω_1^ ... ](ω) = F[ε_(Ω+1)](ω) で達すると考えられます。
F[ F[Ω_2 + 1](Ω_1) ](ω) で ψ(Γ_(Ω+1) 程度になるようです。

少しずつまとめはじめています。
http://gyafun.jp/ln/largenumber.pdf

>>448
おお、乙！
まだ途中までしか見てないけど、すごい丁寧だ

>>448
グラハム数個の乙!

sage忘れスマソ
そういえばなんで途中で文体を変えているの?

おお、すばらしい！
ふりかえってみるとまさかこんなに高度なところまでくるとは
思いませんでしたね。

ちなみに、Hardy functionの定義は

H_0(x)=x
H_α+1(x)=H_α(x+1)
H_α(x)=H_α_x(x) (αが極限順序数のとき)

Hydra gameとの対応を考えた場合はすこし変える必要がありますが、
これでよいと思います。ほとんどの論文等ではH_0(x)=xとしています。

>>450
何て少ないんだ……
おまいには人の心というものがないのか！

・F_α+1(x)
F_αをx回繰り返す関数
・F_α+2(x)
F_αをx回繰り返す関数をx回繰り返す関数
・F_α+ω(x)
F_αをx回繰り返す関数をx回繰り返す関数をx回繰り返す関数を………というのをx回繰り返す関数
・F_α+ω+1(x)
F_αをx回繰り返す関数をx回繰り返す関数をx回繰り返す関数を………というのをx回繰り返す関数をx回繰り返す関数
・F_α+ω*2(x)
F_αをx回繰り返す関数をx回繰り返す関数をx回繰り返す関数を………というのをx回繰り返す関数をx回繰り返す関数を………というのをx回繰り返す関数
・F_α+ω^2(x)
F_αをx回繰り返す関数をx回繰り返す関数を………というのをx回繰り返す関数をx回繰り返す関数を………というのを………
このようなことをx回繰り返す関数
・F_α+ω*3(x)
F_αをx回繰り返す関数をx回繰り返す関数を………というのをx回繰り返す関数をx回繰り返す関数を………というのを………
このようなことをx回繰り返す関数をx回繰り返す関数を………というのをx回繰り返す関数をx回繰り返す関数を………というのを………
このようなことを………
このような………
この………　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　って感じのことをx回繰り返す関数
・F_α+ω*4(x)
めんどい
・F_α+ω*5(x)
めんどいをx回繰り返す関数を………


アーメン

*と^間違えたｗ

>>451
なんとなく、気分で変えてみました。
が、やはり統一しようかな。

>>453
ありがとうございます。
Hardyの説明は手強そうです。
そこまで行くのはまだ先のことになると思いますが、
とりあえず手元のソースファイルを訂正しておきました。

http://web.mit.edu/dmytro/www/other/OrdinalNotation.htm
の表記法を解説していただけるというのはありがたいですね。
自分には数学的知識や英語力が不足しているのか、読んでも理解できなかったので。

ああ

ふぃっしゅっしゅ氏が今までの内容をまとめてる間、雑談程度のスレを
　命数法に上数、中数、下数があり、我々は普段中数を使用している訳だが。
(無量大数は下数なら10＾20、中数なら10＾68、上数なら10＾262144となる。)
この下数や上数の考えかたで矢印記号を考えてみました。
まずは上数矢印記号から

↑の定義は以下のようになる。
a↑b＝a＾a＾・・・＾a　※aの数がb＾b個となる
例）3↑4＝3＾3＾・・・3＾3　※3の数が256個

a↑b↑c＝a↑（a↑（a↑・・・a↑b）））　※（）がb↑b回となる
例）3↑4↑5↑＝3↑(3↑（3↑・・・（3↑4）））　※（）が5↑5回
タワー表記では普通このような表記をしないが、矢印記号の統一を図るため
上数矢印記号では上記のように表記しました。

a↑b↑c↑d＝（a↑b↑（a↑b↑・・・（a↑b↑c）））　※（）がd↑d↑d回となる
例）3↑3↑3↑4＝3↑3↑（3↑3↑（3↑3↑・・・（3↑3↑3）））　※（）が4↑4↑4回
ちなみに、（3↑3↑3）が130個で確実にグラハム数を超えると推測されます。

a↑↑b＝a↑a↑・・・a↑a　※Ｎの数がb↑b個となる
例）3↑↑4＝3↑3↑・・・↑3↑3　で3の数が4↑4個
a↑↑↑b＝a↑↑(a↑↑（a↑↑・・・（a↑↑a）））　※（）がb↑↑b回となる
例）3↑↑↑4＝3↑↑(3↑↑（3↑↑・・・（3↑↑3）））　※（）が4↑↑4回

→の定義は
a→b＝a↑↑・・・↑↑a　※↑の数がb↑b
例）3→4＝3↑↑・・・↑↑3　※↑の数が4↑4個
上数矢印　3→3でコンウェイのチェーン表記で表現できない程大きくなると推測されます。
a→b→cとa→→bの変換は↑と一緒

→の次は↓となり
a↓b＝a→→・・・→→a　※→の数がb→b個となる
以降。←、2回転目↑、2回転→と繰り返していく。

最後に矢印回転の表記を○で表すと
a○b＝a←a　※←はb↑b回転目の←となる。
例）3○3＝3←3　※←は3↑3回転目の←

まあ、通常の矢印記号より遥かに大きい数ではあるが、かなり無節操。その上、
アッカーマン関数を工夫すれば簡単に抜けるだろうし、ふぃっしゅ数バージョン5、
ｂｂ関数、ωからみれば無に等しいけど。

一方、下数矢印記号は

a↑b＝a＾a＾a・・・＾a　※aの数がb個
（通常のa↑↑bから始めるよりa↑bから始めた方が解りやすいので上記のように表記）
例）3↑4＝3＾3＾3＾3

a↑↑b＝a↑（a↑b）
a↑↑↑b＝a↑（a↑（a↑b）
例）3↑↑↑4＝3↑（3↑（3↑4）

a→b＝a↑↑・・・↑↑a　※↑の数がb個
（これも通常のa→b→cよりa→bとした方が解りやすいので上記のように表記）
例）3→4＝3↑↑↑↑3

a→→b＝a→（a→b）
例）3→→4＝3→（3→4）
なお、a→b→c→・・・→zの変換はタワー表記↑で行われないので。矢印記号の統一を
図るため、下数矢印表記では行わないことにしています。

矢印回転○は
a○b＝a←a　※b回転目の←
例）3○4＝3←3　※4回転目の←ｙ

下数矢印記号ならグラハム数を超えるのは3↓130と推測されます。
また、下数矢印記号のa○bは上数矢印のa↑↑bより
小さい値を示めします。（ａ≧2でｂ≧2の時）

僕自身は最初、通常の矢印記号を間違って下数矢印記号のように理解しておりりました。
なお、コンウェイのチェーン表記
ａ→→ａ→→ａ→→ａ
の正しい計算方法が判らないため、
ａ→ａ→ａ→ａ
と同じ計算をすると仮定しています。（その計算も膨大過ぎるため、結果は推測です）

>>463
a→→a→→a→→aは
(a→→(a→→(a→→a)))の順で計算すると僕は思っています（つまり最後から)

>>464
その計算ならコンウェインのチェーンもそれほど大きくならなくてすみますよね。
仮に
Ａ→→ｂ→→ｃ＝Ａ→→（Ａ→→（ｂ-1）→→ｃ）→→（ｃ-1）
だった場合
3→→3→→3＝3→→（3→→26）
3→→3→→4≒3→→（3→→・・・（3→→3）※（）の数が49個
と物凄い勢いで（）が増えていきますからね。
これで行くと、矢印回転の意味合いが変わってきますからね。

>>460
■上数定義
↑↑↑ の定義は合ってる？
↑から↑↑の変化に比べて、↑↑から↑↑↑の変化が小さすぎる。
↑↑↑↑以降の定義も↑↑から↑↑↑に増やした場合と同じ様だとすると、
a○n でやっとコンウェイのチェーンn個のn位の大きさ。

a↑↑b↑↑c や a↑↑b↑↑c↑↑d を a↑b↑c やa↑b↑c↑d と同じように定義して、
a↑↑↑b = a↑↑a↑↑....↑↑a
としないと。

これだと、a→n でコンウェイのチェーンn個のn位の大きさ。

■下数定義
a○b でやっとアッカーマン関数と同程度になるような気がする。
3↓130 ではぜんぜんグラハム数に到達しないんじゃ....

>>465
Ａ→→ｂ→→ｃ＝Ａ→→（Ａ→→（ｂ-1）→→ｃ）→→（ｃ-1）
これは盲点でした確かに凄いことになりますね

>>466
上数定義はご指摘の通り。
Ａ↑↑ｂ↑↑ｃ＝Ａ↑↑（Ａ↑↑・・・（Ａ↑↑ｂ）※（　）の数ｃ↑↑ｃ
A↑↑↑ｂ＝A↑↑A↑↑・・・↑↑A　※（↑↑）の数がｂ↑↑ｂ
が抜けていました。

僕はタワー表記を
　　3↑↑↑↑3
　＝3↑↑↑（3↑↑↑3）
　＝3↑↑↑（3↑↑（3↑↑3）
　＝3↑↑（3↑↑（3↑↑（3↑↑3）
と計算出来ると間違えておりました。勉強になりました。
独学でやっていると間違った計算をそのまま使用してしまいますね。
ところで、矢印2回転目の↑はこのスレではタワーの計算で定義して
るんですかね？それともチェーンの計算方法？

>>468
それはおそらくチェーンでしょう(↑2)はチェーンよりも上位の矢印なわけですし

7 名前：【Bird's Revolving Arrow Notation】 ：03/04/04 19:46
定義をまとめておきます。
参考：チェーンとの対応は(a→b→...→x→y→z)=↑1(a,b,...,x,y,z)
　　　　　タワーとの対応は(a↑...c個...↑b)=(a→b→c)=↑1(a,b,c)

以下a,b,...,zは全て自然数(>0)とします。

まず多変数関数↑1を次で定めます。
↑1(a):=a
↑1(a,b):=a^b
3変数以上に対しては、
↑1(a,b,...,x,y,z):=↑1(a,b,...,x,y) (y=1 or z=1)
↑1(a,b,...,x,y,z):=↑1(a,b,...,x,↑1(a,b,...,x,y-1,z),z-1) (y>1,z>1)

次に多変数関数↑n-1から、多変数関数↑nを作ります(n>1)。方法は、
↑n(a):=a
↑n(a,b):=a^b
↑n(a,b,c):=a^b (b=1 or c=1)
↑n(a,b,2):=↑n-1(a,a,...,a) (aがb個)
↑n(a,b,c):=↑n(a,↑n(a,b-1,c),c-1) (b>1,c>2)
4変数以上に対しては、
↑n(a,b,...,x,y,z):=↑n(a,b,...,x,y) (y=1 or z=1)
↑n(a,b,...,x,y,z):=↑n(a,b,...,x,↑n(a,b,...,x,y-1,z),z-1) (y>1,z>1)

>>469 >>470
回答ありがとうございます。
矢印回転はチェーンの計算を基本にしているんですね。
ただし、コンウェインのチェーン表記のA→→ｂ＝A→A→・・・→A　※Aの数がB個
A→→→ｂ＝A→→（A→→A→→・・・→→A）※(　）無いのAの数がｂ個
は含まないみたいですね。

２日前に何かを検索する途中、なぜか「グラハム数」に出会ってしまいました。
（何を検索していたのかは忘れましたが･･･）
その「暴力的」な増加（というか爆発と表現する方が適切か？）の先に得られるグラハム数に驚愕しました。
また同時にえも云われぬ高揚感を抱きました。

それからすぐに巨大数研究室のページに辿り付き、過去スレの１〜６を貪るように読みふけりました。

正直、かなり序盤の方で僕の理解を超える議論がなされていましたが
巨大数探索（今となってはこの表現は不適当でしょうが）スレッドには
ログを読むことを放棄させない魅力、というかなんらかの魔力のようなものがあります。

個人的に確実に理解できているのは今のところチェーン表記がせいぜいというアフォっぷりです。
アッカーマン関数の爆発具合はなんだか凄い、というのも分かります。

熱心に議論している諸氏に対して不謹慎かもしれませんが
スレの途中に出てくるプロジェクトXやRPG風の記載をおもしろく読んでいる程度です。

そんな僕ですがひとつ疑問があります。
今更すぎてスレ汚しなのは承知していますが恥をしのんで聞かせてください。

Hardy functionについて順序数ωが理解できません。
自然数全体集合についての最小の無限順序数がωとのことですが
「つまりωは自然数ではない」との理解でいいのでしょうか？
自然数 → 整数 → 有理数 → 実数･･･というような広がりとは根本的に異なるのでしょうか？

>>473
「ωは自然数ではない」との理解でいいです。

例の文書を書く中で、バード数と多変数アッカーマンの比較などをして
いたところです。

A(1,0,2,1,2)がバード数よりも大きい事が分かりました。

＞A(1,0,2,1,2)がバード数よりも大きい
ど、どういうことですか?
0と1と2しかないのに

Veblen関数の日本語wikiが書かれています。

http://ja.wikipedia.org/wiki/%E3%83%B4%E3%82%A7%E3%83%96%E3%83%AC%E3%83%B3%E9%9A%8E%E5%B1%A4

>>476
細かい計算は、おいおいアップする文書に書く予定です。
興味のある人は楽しみにしていてください。

Aの定義にしたがって計算して行くと、

A(1,0,0,0,x)=A(x,0,0,x)≒↑x(x,x,x)
A(1,0,0,n,x)>X_n(x)

A(1,0,0,1,0)=3
A(1,0,0,2,0)≒↑3(3,3,3)>G
A(1,0,0,3,0)>↑G(3,3,4)=N
A(1,0,1,4,0)>H
A(1,0,1,5,0)>X_H(N)
A(1,0,2,1,2)>B(バード数)

といった感じになります。細かい計算をしなくても、

バード数の定義の X_n(a) の入れ子操作n回 ≒ F[ω^3+ω+1](n)
A(1,0,2,1,n) ≒ F[ω^3+ω*2+1](n)

から考えると妥当な結果だと思います。

> 0と1と2しかないのに

1だけでも十分ですよ。
A(1,1,1,1,1) > A(1,1,1,0,B) ですから。

バード数 < Ak(1,0,1,2,2)

-------- バード数の定義 --------
X[0](n) = ↑n(n,n,n)
X[m+1](n) = X[m]^n(n)

N=↑G(3,3,4)
f(n) = X[n](N)

バード数 = f^(f^2(N)+1) (N)

※↑n(n,n,n) の定義は「巨大数探索スレッド５」の >>7
※n, m = 1,2,3,....
-------------------------
であってるかな？

g(n) = X[n](n) とすると、
g(2) > N となって、g^(n+1)(2) > f^n(N) となり、
バード数 = f^(f^2(N)+1) (N) < g^(g^3(2)+2)(2) となる。

g(n) < Ak(1,0,1,0,2n) から、
g^n(2) < A(1,0,1,1,2n) となり、
g^(g^3(2)+2)(2) < Ak(1,0,1,1,Ak(1,0,1,1,6)*2+4) < Ak(1,0,1,1,Ak(1,0,1,1,Ak(1,0,1,2,0))) = Ak(1,0,1,2,2)

よって バード数 < Ak(1,0,1,2,2)

>>478-480
50%くらいはわかりました、しかし5変数でこれならn変数akとかはどうなってしまうのだろう?

n変数でH[ω^ω^(n-1)]くらいに相当すると思われます。

>>482
じゃあH[ε_0]のほうがはるかにでかいんですね,すごいぞHardy function

busy beaver function のほうがはるかにでかい

BBはなぁ。
でかいことはわかっているがどれくらいでかいかさっぱりわからんからなぁ。

>>466
＞＞468の修正定義で計算し直してみました。
下数矢印でグラハム数を表記すると
3○（3○・・・（3↓（3→（3↑3）※3○（が63個と計算できました。
ただ、上数矢印の方なんですが、コンウエインのチエーン表記が
4→4→4→9＜4→4→4→3→2であり
（最後の数が多き時よりチェーンを伸ばして3→2にした方が大きい）
a→a→・・・→3→2＝a→a→・・・（a→a→・・・〜（a→a→・・・→a)
※Aの数がｎ個の場合（　）の数が（A→A→・・・→A）Aがｎ個
と計算で出ます。
例）4→4→4→3→2＝（4→4→4→（4→4→4→（・・・（4→4→4）
（　）の数が4→4→4個
すると上数矢印が
a→a→・・・→a＝a→a→・・・（a→a→・・・〜（a→a→・・・→a)
※Aの数が（ｎ+1）個の場合（　）の数が（A→A→・・・→A）Aがｎ個
となるので、チェーンｎ個のｎに相当すると計算がでたんですが？
例）4→4→4→4＝（4→4→4→（4→4→4→（・・・（4→4→4）
（　）の数が4→4→4個
また、コンウェインのa→→→・・・→a（右の数がｎ個）と
上数矢印のa↑↑↑・・・↑a（↑がｎ+1個）が同程度になる。
まあ、上のA(1.0.2.1.0）と比べると無に等しいですが。

>>480
なるほど、そうやって計算するんですね。

たとえばグラハム数だと

f(n)=3→3→nとすると
f(n)<A(1,0,n+2) から
f^n(n)<A(1,1,n+2) となり
グラハム数 = f^64(4) < A(1,1,66) < A(1,1,A(1,2,1)) = A(1,2,2)

よって グラハム数 < A(1,2,2)

といった感じかな。

たぶん A(1,2,1) = A(1,1,61) < グラハム数 < A(1,2,2)

よく考えたら、>>487の計算はすでに自分がしていました。

http://www.geocities.co.jp/Technopolis/9946/log/ln023.html
ここの320がF1の定義、329-331がS変換の計算。

S変換をn回施した後のg(x) = A(n-1,x,x)
S変換を2回施した後のg(2) = A(1,2,2) > グラハム数

ふぃっしゅ数バージョン3(F3)と多変数アッカーマンの関係

F3改良型

関数f(x)からg(x)への写像s(n) (n>0)を以下のように定める。
s(1)f:=g; g(x)=f^x(x) [原始帰納]
s(n)f:=g; g(x)=[s(n-1)^x]f(x)f (n>1) [n重帰納]
　　　　　　　　　　　　　　　　　　　　　（以下略）
（注）旧F3のs(n)が、新F3のs(n+1)に相当する。

このとき、f(x)=x+1として
[s(1)^a1][s(2)^a2]...[s(n)^an]f(x) = A(an,...a2,a1,x)

>>466
>>486です。
3→3→3→4と3→3→4→3を計算すなおして自分の間違いに築きました。
チェーン表記は僕の理解より大きな数字なんですね。

Hardy functionすげえなF_α+1(x)あたりから計算してみたけど
F_α+ω^3(x)で矢印回転関数を超えてしまった

α？

＞>>266 のように、ある言語を用いて大きな可算順序数を作ることを考える。
＞n文字（またはn単語、nトークンなど） で表せる最大の可算順序数を
＞o(n) とした場合、この極限 lim o は可算なのだろうか？
＞
＞可算だとすると、
＞帰納的定義では到達できないほど大きな可算順序数が存在することになる。
＞
＞非可算（つまりΩ）になるとすると、
＞可算順序数の列で、極限が非加算になるものが存在することになる。

結局これってどっちなの？ビジービーバーっぽいけど…
可算だとしたらBB(x)に匹敵するH[可算順序数](x)が存在するってこと
になるのでは？

グラハム数<A(1,2,2)
グラハム数の大きさに仰天していた時代がなつかしい、いまじゃこんな（相対的に）小さい
数になってる

>>493
その文だと分かりにくいが、ω_1^CKのことか
ω^1_CKなら、可算かつ計算不可能な順序数

>>493
って、>>268-273で既に答えられてるじゃないか

というか、可算のものを用いて可算ステップの構成を行ったとき、
その結果は絶対に可算だよ。

あの、懲りずに勉強会などやりたいのですが。
場所は文京区シビックセンター和室(と思われます。)

前回は告知がグダグダだったのでトータル2人でした。
11/3あたり場所取りできるかも(他力本願)なので初心者からガチの方まで
参加して頂ければ幸せです。
日程、場所は変更することがあります。
気になった方はメール欄のアドレスに送ってどうのこうのして頂ければ。

特にガチで戦える方、切実にご教授を望みます。素人計算だけでは無理です。

なぜメ欄にねぎ姉さんの作者のメアド？

mixiでばらしているのですが、わたくし「もやしっ子」が
「ねぎ姉さん」の作者だからです。

ねぎ姉さんの作者がこんなスレに来るなんて意外だ。
東大でゼミをやると聞いて最近驚いたばかりなのに。

このスレにいることより、初期からいて研究室を立ち上げた
もやしっ子だったのが驚き

ねぎ姉さんって誰?

　　　　　　　　,．-─ ─-､─-､
　　　　　　, イ)ィ　-─ ──- ､ﾐヽ
　　　 　 ノ ／,．-‐'"´ ｀ヾj ii /　 Λ
　　　 ,ｲ／／ ^ヽj(二ﾌ'"´￣｀ヾ､ﾉｲ{
　　 ノ/,／ミ三ﾆｦ´　　　　　　　 ﾞ､ﾉi!
　　{V /ミ三二,ｲ　, -─　 　 　 　 Yｿ
　　ﾚ'/三二彡ｲ　 .:ィこﾗ 　 ;:こﾗ 　j{
　　V;;;::. ;ｦヾ!V　　　 ｰ '′　i ｰ '　ｿ
　　 Vﾆﾐ( 入　､　　 　 　r　　j　　,′
　　　ヾﾐ､｀ゝ　　｀ ｰ--‐'ゞﾆ<‐-イ
　　　　　ヽ　ヽ　　　　 -''ﾆﾆ‐　 /
　 　 　 　 |　　｀､　　　　 ⌒　 ,/
　　　 　 　|　　　 ＞ ---- r‐'´
　　　　　　ヽ＿ 　 　 　 　 |
　　　　　　　　　ヽ ＿ ＿ 」

　　　　　ググレカス [ gugurecus ]
　　　（西暦一世紀前半〜没年不明）

ネギまとはかんけいないのか…。

>>460の上数矢印はとても上数とは呼べる品物ではなかったので。改めて上数の方を
定義しなおしてみました。今度は矢印回転でｎ重帰納関数になったと思うんですが。
段落ごとに整理して定義してみます。

�@ａ↑0＝ａ ａ↑ｂ＝a＾a＾・・・a＾a　※＾の数がｂ個
例）3↑1＝3＾3
　　3↑3＝3＾3＾3＾3

�Aａ↑↑0＝ａ　※以降右の数字が0のときはａとなります。
ａ↑↑ｂ＝ａ↑（ａ↑↑（ｂ-1））　※タワーの計算と一緒
例）3↑↑2＝3↑（3↑3）
　　3↑↑3＝3↑（3↑（3↑3））

�Bａ↑↑↑ｂ＝ａ↑（ａ↑↑↑（ｂ-1））　

1-�@ａ→↑ｂ＝ａ↑↑・・・↑ａ　※↑の数がｂ個
例）3→↑4＝3↑↑↑↑3

1-�Aａ→↑↑ｂ＝ａ→↑（ａ→↑↑（ｂ-1））　
例）3→↑↑4＝3→↑（3→↑（3→↑（3→↑3）））　

2-�@ａ→→↑ｂ＝ａ→↑↑・・・↑ａ　※↑の数がｂ個
例）　3→→↑4＝3→↑↑↑↑4　

2-�Aａ→→↑↑ｂ＝ａ→→↑（ａ→→↑↑（ｂ-1））　
※→を伸ばす操作が2重帰納関数

1-1-�@ ａ↓→↑ｂ＝ａ→→・・・→↑ａ　※→の数がｂ個

1-1-�A ａ↓→↑↑ｂ＝ａ↓→↑（ａ↓→↑↑（ｂ-1））　

1-2-�@ ａ↓→→↑ｂ＝ａ↓→↑↑・・・↑ａ　※↑の数がｂ個

2-1-�@ ａ↓↓→↑ｂ＝ａ↓→→・・・→↑ａ　※→の数がｂ個
※↓を増やす操作が3重帰納関数

矢印の回転数を○で表すと
ａ○ｂ＝ａ←↓→↑←・・・→↑ａ　※矢印記号がｂ個
※ｂの数値を増やす操作がｎ重帰納関数

ここまで書く気がつく人も多いと思いますが、↓→↑の記号の意味を
左の段階を表す1-1-�@のほうが簡単に表してます。
そこで実際の上数矢印は
ａ（ｚ-ｙ-・・・ーｆ-ｅ-ｄ-↑ｃ）ｂと表記します。　
例）　7（3-2-4-↑5）6≒7←←7←←7←←7←←6←←5
※コンウエインのチェーン表記の→→の定理を含んだ矢印回転表記です。
また、グラハム数＝3（1-↑1）64となります。

簡単すぎて　ツマンネーーーーーーーー

N (...-b3-b2-b1-↑b0) c = ↑[..., b3, b2, b1, b0, c] と書くことにすると、

↑[Ｘ, 0] = N
↑[□, 1, a+1] = N ^ ↑[1, a]
↑[□, 1, 1, △, a+1] = ↑[a+1, △, N]
↑[Ｘ, b+2, 1, △, a+1] = ↑[Ｘ, b+1, a+1, △, N]
↑[Ｘ, b+2, a+1] = ↑[Ｘ, b+1, ↑[Ｘ, b+2, a] ]
N○a = ↑[1がa個, N]

ただし、
a, b : 0以上の整数
N: 1以上の整数
□: 0個以上の0
△: 0個以上の1
Ｘ: 0個以上の0以上の整数

まとめるとこんな感じかな？


�Bａ↑↑↑ｂ＝ａ↑（ａ↑↑↑（ｂ-1））
これは
�Bａ↑↑↑ｂ＝ａ↑↑（ａ↑↑↑（ｂ-1））
これの間違いですよね？

>>508
ご指摘の通り間違いです。訂正ありがとうございます。

あ、どうも。
ふぃっしゅしゅ氏とメールでコンタクトを取っています。
僕と遊んで頂けるようなので、2人だと寂しいから誰か来ませんか。
当日の内容は、集まったメンツと流れ次第で決める感じで。

なんだ、まだやってたのかこのスレ

ちなみにHNは「うるさいぞう」って読むんだよｗ

実は関東在住でヒマだから行ってやってもいいけど
もう昔のことなんか忘れちまったよｗ

ちょっと過去ログみたら、モヤシが、カナモリの本持ってるって書いてあって
「をひをひ、そこまでやるか。でも、オレも買ったけど」なんちってｗ

そういえば、どっかの集合論フリークのブログで0#の話書いてあったな。
今のオレはあの程度でもうおなか一杯っていうか、別方面に関心があるんで。

最近凝ってることの一つは、自然数を素数だけで表すこと

自然数は素数の積で表せるが、その場合素数の指数に表れる
自然数をまたシツコク素数の積で表し・・・なんて続けると、
いい加減どっかで１になる。

こうやって出来た素数による「木」を見て眺めるわけだ。
まるで爺ィの盆栽趣味だなｗ

木か。
木もうまく使えば巨大数生成に役立つかもね。
ていうか多重リストが木に相当するのかな。

>>342の多進木がそれかな。

盆栽というか、そのものぢゃないですか。趣があっていいと思います。
カナモリ氏の本はね…僕はいまだにforcingも使えませんからね…

思うにあの頃の才蔵氏はツンデレの最先端を地で行っていたと思います。
今回集まってやるのは、よくて才蔵氏の後を追っかけるようなものなので
(Hardy関数ってなんぞ、とかそういう)
半端なことやってるの見られたらリアル雷落とされちゃうかな？
みたいな。
ま、ママゴトですからよかったらお気軽にどうぞ。

>>512
なんとなくコラッツ予想の木を思い出した

＞僕はいまだにforcingも使えませんからね…
はっはっは、･･･実は漏れも使えん･･･ＯＴＬ

＞思うにあの頃の才蔵氏はツンデレの最先端を地で行っていたと思います。
漏れは涼宮ハルヒかっ！
しかし、このスレに本当に必要なのは・・・長門有希だな・・・
実際には、朝比奈みくるみたいのばっかりだが。
み・み・みらくる・みくるんるんｗ

そういえば、512でいってた写像だけど
木に適当な順序をつければε_0になるので
実は自然数をε_0にみなせるんだよね。

順序数を木で表し、最も効率の悪い切り方（常に一番端から切る）をした
時にすべてをカットしたときの手数をnとすると、
n=Hα(1)-1 α<ε0
となる。
ただし、
H0(x)=x
Hα+1(x)=Hα(x+1)
Hα(x)=Hα[x+1](x+1) (αが極限順序数のとき)
とする。

>>519
＞順序数を木で表し
kwsk

前スレ辺りのHydra gameを要約しすぎたんだと思われ

ところで５スレの６８２ってのは呼びにくいな。
初登場は2003年10月10日か。もうこの頃漏れは別スレで暴れてたな（をひ
（この流儀でいくと
　漏れ様は３スレの２６４(2002年11月7日初登場)
　モヤシは２スレの６９５(2002年8月8日初登場)
　サカナは２スレの１４８(2002年6月20日初登場)）

じゃあ、漏れが渾名をつけてやろう。
ナゴヤンってのはどうだ（ｗ

有流才蔵マジキモイ

>>380
＞まずはふぃっしゅ数ver.5の定義をはっきりさせる
＞ところからはじめようと思います。

なんかでじゃぶーｗ

もちろん、対角化によって増大度を上げることはいくらでもできるよ。
ただこの場合、関数の列をどう構成するかがカギなので、
そこが記述できてないと全然意味がない。

早い話が、ＢＢだって対角化。でもこの場合関数の列を構成する
手続きが書けないから、関数を手続きとして考える場合には失格。

Hardy関数は、順序数の構成手続きによって、関数の列を構成する
手続きが決まるから、その意味では合格。

>>448をみた。
発想としてはprimitive recursive functionalを用いる
Goedelの自然数論の無矛盾性証明に通じるものか？
ちなみにprimitive recursive functionalによって
作れる関数の範囲はε_0より小さい超限帰納法による
ものと同等。

(ふぃっしゅ評）
>打たれても打たれても立ち上がってくる、
>ジャンプ系の主人公
>戦隊組んだら、間違いなく赤

ふーん。じゃ、後から出てきて
Hardyだのなんだのと、エエとこどりの
ナゴヤンはさしずめクールな青か。

モヤシは・・・喫茶店のマスターだなｗ

そんでもって、漏れは悪役。
イメージとしてはレインボーマンに出てくる
死ね死ね団の団長、ミスターＫだな。

現時点で、具体的な計算方法が示されている関数の中で
一番大きいのはH[ψ_0(Ψ)]なのかな。
>>391の方針でうまくいけば、もっと大きい関数が作れそうだけど。

もうなんか巨大順序数探索スレって感じになって来たな。
より大きな帰納的関数を作れば作るほどビジービーバーが
どれだけたがの外れた増加をするのかがわかってくるな。

>>111
>過去ログによれば、
>ふぃっしゅ関数ver.1<F[ω^2]、
>ふぃっしゅ関数ver.2<F[ω^3]、
>ふぃっしゅ関数ver.3はF[ω^ω*63]程度

漏れとしては
・ver.1の評価・・・○　(6スレ526-527)
・ver.2の評価・・・△　(6スレ527-529)
・ver.3の評価・・・×　(6スレ544)
(どうみてもω^ω未満。あれではω＾ωが出来たとはいえない）

>>289　>>292
たろうクン、289が正しいよ。292はまちがっとる。
さらに、ω＾ωのレベルになったら、加えたんじゃダメ。掛けなくちゃ。
したがって
>>311
＞ふぃっしゅ数バージョン５のf5(n) ≒ F[ε_0](n)
は却下。差し戻し。

>>387　>>388

力づくで間違ったな。

>m3 m2 ===> +ω
･･･
>m3 m3 m2 ===> ω^2
>m3^a m2 ===> ω^a

ここが力づくの誤り。
そんなことはふぃっしゅは書いてない。

>>531　
書いてないから、これはたろうクンのオリジナルな貢献だ。
たろうクン、おめでとう。

ということで、勝手ながら
ふぃっしゅ５に対するたろう氏の解釈を入れた関数を
ふぃっしゅ＝たろう関数、いや、たろう関数、と
呼ぶことにしたい（ｗ

（オリジナルはむしろ前スレだと思うんだが）

>>533
6スレ305の魚スキーのことか？
だったら、魚スキー関数だな。

魚スキーの解釈は、こういうことらしいが・・・
果たしてふぃっしゅのいう高階関数による"定義"と一致するかい？
(高階関数＝汎関数(functional)だから、
　Goedelの仕事と関連づければうまくいきそうな気はするが）

＋１ １、２、３、・・・
(m2) ＋ω ω、２ω、３ω、・・・
m2^n　　×ω ω、ω＾２、ω＾３、・・・
(m3) ×（ω＾ω） ω＾ω、ω^２ω、ω＾３ω、・・・
m3^n　　＾ω ω＾ω、ω＾（ω＾２）、ω＾（ω＾３）、・・・　
(m4) ＾（ω＾ω） ω＾（ω＾ω）、ω＾（ω＾２ω）、ω＾（ω＾３ω）、・・・
m4^n ＾＾ω ω＾（ω＾ω）、ω＾（ω＾（ω＾２））、ω＾（ω＾（ω＾３））、・・・
(m5) ＾＾（ω＾ω） ω＾（ω＾（ω＾ω））、ω＾（ω＾（ω＾２ω））、ω＾（ω＾（ω＾３ω））
・・・

もちろん、これでうまくいくのはε_0より小さい部分だけだが

>>511
> もう昔のことなんか忘れちまったよｗ

と言っている割には、よく覚えてますね。

>>522
さすがに関東地方までオフ遠征は時間がなくきついです。
東海地方でやるのなら大丈夫ですがさすがにありえないようですね。

>>528
自分がHardy関数を応用して順序数から巨大関数を
作ることを発案してから皆巨大順序数に追求してしまいましたからね。
自分も今はΩ_ωの段階からさらにΩ_Ω_ ... _ωまでの順序数を考えて、
そこからさらに [1,0] → [1_Ω_n, ... , 1_1] = [Ω_n | 1] → [ [ω | 1]_Ω_n, ...]
と多重リストと順序数を組み合わせたナゴヤ関数Ver2みたいなものも
考えてたりしています。
Ver1.1ではとりあえずF[1_ω, ... , 1_2, 1_1](x)程度にしておきます。

たろう関数とかライバル的な存在も出てきてさらに面白くなると思ってます。

>>532
ふぃっしゅ数バージョン５の定義から単純に導いただけで、
新たな定義を加えてはいません。
だから「たろう関数」ではなく「ふぃっしゅ関数バージョン５」です。

m2 ===> +1　　 （f ≒ F[a] の時、 m2 f ≒ F[a+1] という意味）
m2 m2 ===> +2　　（f ≒ F[a] の時、 m2 f ≒ F[a+2] という意味）
m2^a ===> +a ....☆1

ここまでは理解していただいたようなのでこの先。

m3 の定義より、
m3 m2 f (n) = m2^n f (n) で、　　........ただし、f∈M_1, n∈M_0
これと☆1より、f ≒ F[a] の時、m3 m2 f (n) = m2^n f(n) ≒ F[a+n](n) となる。
F の定義より、F[a+n](n) = F[a+ω](n) であるので、

m3 m2 ===> +ω　...☆2

またm3の定義より、
m3 m3 m2 f (n) = (m3 m2)^n f(n) で、　　........ただし、f∈M_1, n∈M_0
これと☆2より、f ≒ F[a] の時、m3 m3 m2 f (n) = (m3 m2)^n f (n) ≒ F[a+ω･n](n) となる。
F の定義より、F[a+ω･n](n) = F[a+ω^2](n) であるので、

m3 m3 m2 ===> +ω^2

計算可能でない関数についてもう一度考えてみました。

>>232 や >>282 は実はあまり大きくなく、ビジービーバーのハーディー関数的拡張と大差ないです。
つまり、B[a](n) を、
B[0](n) = n
B[a+1](n) = BB｢ B[a] ｣(n)
B[A](n) = B[A_n](n)
と定義したとき、B[a](n) ≒ M[a](n) となるようです。
（....BB｢｣ >>228 のもの）

ふぃっしゅ数V4は
>ふぃっしゅ関数ver.3はF[ω^ω*63]程度
これが正しいとすると、F4(n) ≒ B[ω^ω*63](n) 程度となります。

>>229 の CC は
B[帰納的でない最小の順序数](n) 程度となります。

>>233 は>>229 の拡張のつもりでしたが、動作が足りなくてあまり大きくないようです。

ハーディー関数の順序数を帰納的でないものまで拡張すると、
大きな関数が作れます。

ω_1^CK　　(Church-Kleene ordinal)
ω_α^CK
などを使います。
テキストで見やすいように、ω_1^CK = CK, ω_α^CK = CK[α] と書くことにし、
便宜的に CK[0] = 0 とします。

CK[0] = 0
CK[a+1]：CK[a] と帰納的定義で作れない最小の順序数
CK[A]：limit CK[A_n]

となります。
CK[a+1] の収束列は、たとえば >>267 のようにします。
つまり、CK[a] と帰納的定義をある表現でn文字で行い、
その中で得られる最大の順序数を S_n としたとき、
CK[a+1] = limit S_n とします。

BB ≒ F[CK]
BB｢BB｣ ≒ F[CK･2]
M[a] ≒ B[a] ≒ F[CK･(1+a)]
CC ≒ F[CK^2]

CK^CK、CK[CK]、CK[CK[.....[CK]]...] など、
順序数から順序数の変換 CK[ ] を用いるとより大きな順序数が作れますが、
これを効率的に行うには以下のようにします。

T[0] = 0
T[a+1]：順序数T[a] と、順序数から順序数の変換CK[ ] と、帰納的定義で作れない最小の順序数
T[A] = lim T[A_n]

多変数化、Ωの導入、C0からC1に拡張したときのような拡張.....
などでさらに大きくすることが出来ます。

いよいよ新展開ですね。

頭文字Tが登場したところで、「たろう関数」を定義しては
いかがでしょう。F[T[CK]]とか。

あ

＞m3 の定義より、
＞m3 m2 f (n) = m2^n f (n) で、

＞またm3の定義より、
＞m3 m3 m2 f (n) = (m3 m2)^n f(n) で、

それはキミの定義だよ。ふぃっしゅの定義は全く存在しない。

＞定義から単純に導いただけ

その定義は全てキミの定義
ふぃっしゅは何も定義しなかった。できなかったんだよ。

>>543
といっても、実際にたろう氏（魚スキー氏？）がやったのは
ふぃっしゅのmnをハーディ関数で解釈しただけ。
実際に仕事したのはハーディか（ｗ

ふぃっしゅは"高階関数"といったのだから、それを生かす形で、
ハーディ関数との関係を示そう。それができてはじめて
”ふぃっしゅの主張”を汲み取ったことになる。

>>543
>>396 の定義より

(..((m(n+1)f_n)f_{n-1})...f_1)f_0:=(..(f_n^{f_0}f_{n-1})...f_1)f_0

括弧を省略し、n => 2, f_2 => m2, f_1 => f, f_0 => n
とすると
m3 m2 f (n) = m2^n f (n)

ほとんど定義そのまま。

また、f_2 => (m3 m2) とすれば、
m3 m3 m2 f (n) = (m3 m2)^n f (n)

>>545
>n => 2, f_2 => m2, f_1 => f, f_0 => n　とすると
ほら、そこがオリジナルｗ

要は
>(..((m(n+1)f_n)f_{n-1})...f_1)f_0:=(..(f_n^{f_0}f_{n-1})...f_1)f_0
ではダメなので
>(..((m(n+1)m(n))m(n-1))...m(2))f)(x):=(..(m(n)^(x)m(n-1))...m(2))f)(x)
と書くべきであった。

つか、前スレにちゃんと5-714によるλ項による定義あるじゃんｗ

6-52

>m~(1)=λ f_0．f_0 f_0
>m~(2)=λ f_1f_0．f_0 f_1 f_0
>・・・
>m~(n+1)=λ f_n f_{n-1} ... f_0．f_0 f_n f_{n-1} ... f_1 f_0

うーん、もう長門有希はあらわれてたんだな・・・ＯＴＬ
で、誰かこれ試したかい？

代入がオリジナルなのか…？

>>548
つか、実はエッセンスである５スレの14の
ふぃっしゅの記述が混乱していたのが
問題の始まりなのだ。

5-14
> m(x)^xはm(x+1)m(x)とほとんど同じなので、

こんなことを書くから「でも本当は違うのか？」などと勘繰られる。

実際は、ふぃっしゅはこう書けばよかった。
「m(x+1)m(x)はm(x)^xとして"定義"されるので」

ふぃっしゅ関数Ver.5の決定版定義

m(1):　（自然数→自然数）
m(1)x=x^x
m(2):　（（自然数→自然数）→（自然数→自然数））
(m(2)m(1))x=(m(1)^x)x
m(3):　（（（自然数→自然数）→（自然数→自然数））
　　　　→（（自然数→自然数）→（自然数→自然数）））
((m(3)m(2))m(1))x=(m(2)^x m(1))x

一般に、自然数ｎに対して、m(n+1)は以下のように定義される。
(･･･((m(n+1)m(n))m(n-1))･･･m(1))x
=(･･･((m(n)^x m(n-1))･･･m(1))x

ふぃっしゅ関数Ver.5はm(n)を用いて以下のように定義される。
F5(x):=((..((m(x)m(x-1))m(x-2))...m(2))m(1))(x)

ふぃっしゅ関数Ver.5の歴史

2003年4月5日　5スレ10、11、14
・ふぃっしゅ氏、ふぃっしゅ関数Ver.5のアイデア
　しかしながら、当時は"多重帰納法"ブームの只中で
　そこから外れた発想であるVer.5は
　しばらく省みられることなく・・・
2004年4月24日　6スレ5
・再び注目され始める
2004年5月2日　6スレ37　
・5-714氏　によるλ項の記述
2005年8月29日　6スレ303-305　
・魚スキー氏　によるHardy関数を用いた評価（H[ε_0]相当）

　ふぃっしゅ関数についていえば、Ver.1ではアッカーマンを
本質的には越えていなかったが、Ver.2でアッカーマンを越え
Ver.3ではほぼ多重帰納法に相当するところまで実現していた
と考えられる。
Ver.5は、これら過去の版を基礎として、結果としては
単純な高階関数を用いた、スッキリとした形で記述された
ふぃっしゅ関数の集大成といってよい。

追伸

正確にいえば、5-714氏によってなされたのは
ふぃっしゅ関数Ver.5の断片であるm(n)の記述であり
これらだけを用いてはH[ε_0]には至らない。

もちろん、ふぃっしゅ関数Ver.5自身をλ項で記述することは
可能であると考えられるが、その場合記述における根本的な
発想の転換が必要と考えられる。

さて過去の総括はこの程度にして
未来への展望を述べてみようか。

まあ、ε_0の次の目標はΓ_0だろうな。
漏れが聞きかじったところでは、Kruskalの定理の証明に
Γ_0までの超限帰納法を用いるらしいから。
Γ_0そのものは無理としても、そこに近づく関数の記述は可能だろう。

Hardy関数は便利かもしらんが、そこで用いられるΛ(x)を
具体的に表すことこそがこのスレッドの意義である。

え？ナゴヤンについてはどう思うかって？知らんよそんな小僧ｗ

最近のオーディナルキッズは、このスレの本質分かってないだろ？
漏れにいわせりゃ「大きいことはいいことだ」なんてのは、
もう１９７０年代のフレーズなわけで。え？知らない？
そんなころには母親どころか父親の中にもいなかった？
じゃ山本直純とか森永エールチョコレートとか知らんわけ？
やれやれ、ほんとにこのスレは小僧ばっかりだな・・・ＯＴＬ

これはひどい…

>>113
＞多変数関数やリスト構造などを利用した大抵の関数よりもH[ε_0]の方が大きい。

まあ、これは正しい。しかし、だからといって

＞それならば、巨大な順序数を作ってHardy functionを利用する方が
＞簡単に大きな関数が作れます。

こういう安直な方針はつまらない。
やっぱり若いうちは汗をかこう。他人のふんどしで相撲を取るな。

リストでダメならツリーがある。これでε_0は越えられるはず。
で、その場合の新たな限界点はおそらくΓ_0のはず。
昔読んだ、マーチン・レーフの構成的型理論の無矛盾性は
Γ_0までの超限帰納法で証明するとかなんとか聞いた希ガス。

>>545の
f_2 => (m3 m2) とすれば、
m3 m3 m2 f (n) = (m3 m2)^n f (n)
という計算は、>>550の定義ではできない、はず。

>>553
> Λ(x)を具体的に表すことこそがこのスレッドの意義
そう思うなら、やってみたら？
たしかスネークがあったと思うけど、>>337によれば
あれはω^ω程度のようだし。とりあえずε_0を超えないと。

ふぃっしゅ氏も>>418-419でチャレンジしたけれど、
まだ「ε_1にも到達しなさそう」らしい。

>>338-350の多進木が一つの方法だとは思うけどね。

Veblenも338もω^αが基本になってたよね？
これをそのままF5に応用しようと思ったら
「例えば(m(3)m(2))fという関数を(m(4)m(3))m(2)というM2変換に
変換する方法」
みたいなものが必要になる。たぶん無理。

>>556
確かに、最初に順序数のことを知って>>98を書いた後、
すぐに>>113みたいな考えを書き込んだのは、考えが浅かったでしょうね。
順序数を利用した関数が大きいからそれ以外は無意味だ、なんてことはないし、
ある方法だけにこだわるよりは色々な方法を考えた方がいいわけで。

ただ、「他人のふんどしで相撲を取る」こと自体が悪いとは思いません。
学問は過去の他人の業績を土台にして発展していくものなので。
とはいえ、他人の考えをただ利用しただけのつまらない関数を作るのは良くないですが。

もともと大きいものに憧れてこのスレに来た自分としては、
「ひたすら大きな数を目指す」というのも一つの方針としては面白いと思います。

>>557
1.(m3 m2)のまま計算する必要はない。どうせ解くんだから。
2.やってみる必要なし。スネーク？忘れたなｗ。ふぃっしゅ５万歳（ｗ
　ついでに、画竜点睛ってことで、H(ε_0)到達版を。
　mm変換を考える。
　mm(n,m)
= mm(n-1,1) n (m=0)
= mm(n-1,m+1) m(m)
= m(m) (n=0)
　例えば
　mm(3,0)
= mm(2,1) 3
= (mm(1,2) m(1)) 3
= ((mm(0,3) m(2)) m(1)) 3
= ((m(3) m(2)) m(1)) 3
これでふぃっしゅ５は、Urusaizo関数になったな（ｗ

まあ「元祖はうちだ！」議論は好きにやればいいっすね。
定着した呼ばれ方に収束していくでしょう。
さて。
現段階で勉強会(馴れ合い)オフは、僕、ふぃっしゅしゅ氏、たろう氏が
参加希望の名乗りを挙げております。どうせ広い部屋取れば
後からバンバン入って来られるのでいいんですけどね(何が)。
そんな感じなのでオールレンジ対応でお出迎えします。
僕は立ったり座ったりします。お茶入れたり。

>>561
で、何を勉強するんだい？＞勉強会

よく考えたら>>550の定義ではできないな。
つまり、6スレ37のλ項ではできないな。
なぜなら>>550の定義は6スレ37のλ項の動作の記述だから。

なんかPDFにまとめようという企画があるので、空欄部分を埋めていく
ついでにわからん箇所のおさらいであるとか、茶を飲みながら適当に。
勉強といえば勉強ですが、ものは言い様ってことです。

いや、やっぱり>>550＝6スレ37のλ項でOKなようだな。

　(((m(4)m(3))m(2))m(1))2
＝(((m(3)^2)m(2))m(1))2
＝((m(3)(m(3)m(2)))m(1))2
＝((m(3)m(2)^2)m(1))2
＝((m(3)m(2))((m(3)m(2))m(1)))2
＝(m(2)^2)((m(3)m(2))m(1))2
＝m(2)(m(2)((m(3)m(2))m(1))2
＝(m(2)((m(3)m(2))m(1))^2)2
＝(m(2)((m(3)m(2))m(1))((m(2)((m(3)m(2))m(1)))2))
＝・・・

>>有流才蔵氏

結局、>>396 の定義から

m3 m2 ===> +ω
m3 m3 m2 ===> +ω^2
m4 m3 m2 ===> +ω^ω
m5 m4 m3 m2 ===> +ω^ω^ω

が導かれることは理解されたんでしょうか？

＞なんかPDFにまとめようという企画があるので、
それってふぃっしゅ氏個人の仕事のまとめでしょ。
まあ、頑張ってくださいよ（ｗ
＞空欄部分を埋めていく、ついでにわからん箇所のおさらいであるとか、
ふぃっしゅ氏は自分の関数の定義すらアヤシイという話もあるが
それは冗談としても、Hardy functionとの関係の話もあるから、
たろう氏に根掘り葉掘り聞き出せばよろしいんじゃないですか？
それにしても漏れ自身λ項の計算がアヤシイ・・・ＯＴＬ

>>550 では不完全。

m(4) は M_3 から M_3 の元への写像であるのに、
m(4) (m(3)) という特別の場合しか定義されていない。

>>566
396の元は5スレの11だと思うが、あんなもん読めないよｗ
結局5スレの14の「アイデア」から6スレの37のλ項がつくられた、と。

あと、たろう氏、あんたもプログラマなら
λ項くらい読めるようになりなさい。
絶対困りません。いつまでもＣ＋＋ばっかりじゃ飽きるぞｗ

>>568
じゃ、キミ、直しなさい。嬉しいだろ？
ヒトの間違いが直せてｗ

個人的にまとめたものです。

アッカーマン関数の２重リストへの拡張、
多変数C1の収束列の定義、
などを含みます。
そのうち計算可能でないものも足します。

http://1rg.org/up/55364.txt.html

不機嫌な奴は長生きせんぞ

>>570
>>396 のままでも良いけど、
もうちょっとわかりやすく書いてみました。

■■■■ふぃっしゅ数V5■■■■
M[0] : 自然数 の集合
M[n+1] : M[n] から M[n] への写像 の集合
t[n] ∈ T[n]

●g{t[m], t[m-1], ..., t[n+1], t[n]} ∈ M[n] の定義 ...m≧n≧0
　case n=0
　　g{t[m], t[m-1], ..., t[0]} = t[m]^t[0] t[m-1] ... t[1] t[0]

　case n>0
　　g{t[m], t[m-1], ..., t[n+1], t[n]} (t[n-1]) = g{t[m], t[m-1], ..., t[n+1], t[n], t[n-1]}

●m[n] ∈ M[n] の定義 ...n>0
　m[n] (t[n-1]) = g{t[n-1]}

●F5 の定義
　F5(n) = (m[n] m[n-1] ... m[2] m[1]) (n)
　F5 = F5^63(3)

差し替え

■■■■ふぃっしゅ数V5■■■■
M[0] : 自然数 の集合
M[n+1] : M[n] から M[n] への写像 の集合
t[n] ∈ M[n]

●g{t[m], t[m-1], ..., t[n+1], t[n]} ∈ M[n] の定義 ...m≧n≧0
　case n=0
　　g{t[m], t[m-1], ..., t[0]} = t[m]^t[0] t[m-1] ... t[1] t[0]

　case n>0
　　g{t[m], t[m-1], ..., t[n+1], t[n]} (t[n-1]) = g{t[m], t[m-1], ..., t[n+1], t[n], t[n-1]}

●m[n] ∈ M[n] の定義 ...n>0
　m[n] (t[n-1]) = g{t[n-1]}

●F5 の定義
　F5(n) = (m[n] m[n-1] ... m[2] m[1]) (n)
　F5 = F5^63(3)