無限級数の収束加速と定数決定への一試論

「無限を計算機で扱うための、私独自の『観測装置』の設計と実装。」
「この観測装置は、計算機の論理で数学の真理を自律的に抽出する実験場である。ブラックボックスを嫌う全ての設計者へ。」

Infinite Log Axis: 自分の尺度で無限を計る

コンピュータにとって「無限」は数値的な特異点であり、計算を破綻させる要因です。私はこの無限遠を「直接的な計算対象」とするのではなく、独自の変換関数を用いた「対数レンズ」を通して有限のキャンバスへ投影し、真理を不動点として抽出する観測手法を構築しました。

【自己完結型の観測】
近似演算(自己回帰) → 無限対数軸(投影レンズ) → 収束加速による真理の不動点化

0. 無限の有限証明(無限対数軸)


lim↓x→∞　x
MAX_N=任意
n=MAX_N
c=MAX_N/x
lim↓x→∞　c=0
c=無限のとき
　a=0.0
それ以外
　a = MAX_N * Math.Pow(1.0 / n, c)
　lim↓c→0　a=MAX_N
d = x = MAX_N / (Math.Log(a / MAX_N) / Math.Log(1.0 / n))
b = Math.Cos((Math.PI * d) * (2.0 / MAX_N))

0＜x＜∞
0＜a＜MAX_N
dが無限対数軸であり
bが無限対数軸を使用した任意の関数です
つまりaでステップしたときに
aがMAX_Nに行くにつれてbは密度が濃くなっていくということです

無限を有限で表現できた
証明終了

ゼノンのパラドックスの完全解答

1. 無限対数軸という「座標の再定義」

既存の線形な座標系では無限遠は遥か彼方に位置しますが、対数関数をレンズとして投影することで、無限の彼方を有限の数値空間（＝0～Range範囲）に折り畳むことが可能です。これにより、発散する数列を計算機の「有限の器」の中に捕獲し、その挙動を精密にトレースできるようになります。

射影値Projection = 漸化式Sn * getInfiniteLogAxis(x, n);
現在の誤差の勢いestimatedDelta = Math.abs(漸化式Sn - 前回の漸化式Sn-1);
// --- 無限対数軸の変換関数 ---
// x: 無限大に発散する軸の現在の座標 n:nの範囲に折りたたむ最大値
function getInfiniteLogAxis(x, n) {
let c = n / Math.abs(x);
if (!isFinite(c)) return 0.0;
　let a = n * Math.pow(1.0 / n, c);
return n / (Math.log(a / n) / Math.log(1.0 / n));
}
// --- 無限対数軸による漸化式の自動修復関数 ---
// val:現在の漸化式の値 proj:射影値 estimatedDelta:現在の誤差の勢い
function restoredInfiniteLogAxis(val, proj, estimatedDelta){
return rest = val + (estimatedDelta * (val / (proj - val)));
}

2. セルフ・キャリブレーションによる真理の導出

本手法の核心は、外部の数学定数（Math.E等）を一切参照しない点にあります。計算のたびに得られる近似値の「揺らぎ」を誤差（delta）と見なし、これをレンズの調整パラメータへと動的にフィードバックすることで、システムは自身の計算結果を自己修復し、理論上の極限値へと自律的に収束します。表のrestの値が今回求めている自動修復推論値です。

最終推論値:

理論値:

誤差率: 


// --- 無限対数軸の変換関数 ---
// x: 無限大に発散する軸の現在の座標 n:nの範囲に折りたたむ最大値
function getInfiniteLogAxis(x, n) {
  let c = n / Math.abs(x);
  if (!isFinite(c)) return 0.0;
　let a = n * Math.pow(1.0 / n, c);
  return n / (Math.log(a / n) / Math.log(1.0 / n));
}

// --- 無限対数軸による漸化式の自動修復関数 ---
// val:現在の漸化式の値 proj:射影値 estimatedDelta:現在の誤差の勢い
function restoredInfiniteLogAxis(val, proj, estimatedDelta){
    return rest = val + (estimatedDelta * (val / (proj - val)));
}

function runExperiment() {
    const output = document.getElementById('output');
    const final = document.getElementById('final');
    const theory = document.getElementById('theory');
    const delta = document.getElementById('delta');
    const output2 = document.getElementById('output2');
    const final2 = document.getElementById('final2');
    const theory2 = document.getElementById('theory2');
    const delta2 = document.getElementById('delta2');
    
    // --- 1. ネイピア数 (e) の自己校正実験 ---
    output.textContent = "=== Experiment: Euler's Number (e) ===\nStep | 漸化式 E       | 誤差(delta)     
        | 射影値(proj)    | ★推論値(rest)\n";
    
    let rest = 1.0; 
    let e = 1.0; 
    let factorial = 1.0;
    const steps = 15;
    const Range = 8.0; // 1 < Range であればRangeの値は任意ですがここでは適当に2^3にしました


    // 外部のMath.Eを排除し、自身の振る舞いからdeltaを導出する
    let prevE = 1.0;
    let estimatedDelta = 1.0; // 最初は大きな誤差と仮定

    for (let n = 1; n <= steps; n++) {
        factorial *= n;
        e += 1.0 / factorial;

        // 前のステップとの差を「現在の誤差の勢い」と定義する
        estimatedDelta = Math.abs(e - prevE);
    
        // この estimatedDelta を用いて射影を行う
        // これにより、Math.E を使わずに「自分の現在地」を測定できる
        let proj = e * getInfiniteLogAxis(n, Range);
    
        // rest の計算に、自身が導出した estimatedDelta をフィードバックする
        rest = restoredInfiniteLogAxis(e, proj, estimatedDelta);
    
        prevE = e;
        output.textContent += `${n.toString().padStart(4)} | ${e.toFixed(12)} |  ${(Math.E - e).toFixed(12)} 
            | ${proj.toFixed(12)} | ${rest.toFixed(12)}\n`;
    }
    final.innerText = `e: ${rest.toFixed(15)}`;
    theory.innerText = `e: ${Math.E.toFixed(15)}`;
    delta.innerText = `de: ${(Math.abs(rest - Math.E) / Math.E * 100).toFixed(15)} %`;

// --- 2. 円周率 (Pi) の自己校正実験 ---
    output.textContent += "\n\n=== Experiment: Archimedes' Pi (π) ===\nStep | 漸化式 Pi / 2  | 誤差(delta)     
        | 射影値(proj)    | ★推論値(rest)\n";

    let prevPI = 1.0;
    let estimatedDelta = 1.0; // 最初は大きな誤差と仮定

    
    let n = 4;
    let edges = 1;
    let an = 0.0;
    
    for (let step = 1; step <= steps; step++) {
        n *= 2;
        edges *= 2;
        an = Math.sqrt(2 + an);
        const sn = Math.sqrt(2 - an);
        
        let pi2 = (sn * edges);

        // 前のステップとの差を「現在の誤差の勢い」と定義する
        estimatedDelta = Math.abs(pi2 - prevPI);
    
        // この estimatedDelta を用いて射影を行う
        // これにより、Math.E を使わずに「自分の現在地」を測定できる
        let projPI = e * getInfiniteLogAxis(n, Range);
    
        // rest の計算に、自身が導出した estimatedDelta をフィードバックする
        let restPI = restoredInfiniteLogAxis(pi2, projPI, estimatedDelta);
    
        prevPI = pi2;

        output.textContent += `${step.toString().padStart(4)} | ${pi2.toFixed(12)} 
            |  ${((0.5 * Math.PI) - pi2).toFixed(12)} | ${projPI.toFixed(12)} | ${restPI.toFixed(12)}\n`;
        
        // 最終的な計算結果を保持
        if (step === 15) {
            final.innerText += ` | π/2: ${restPI.toFixed(15)}`;
            theory.innerText += ` | π/2: ${(0.5 * Math.PI).toFixed(15)}`;
            delta.innerText += ` | d(π/2): : ${(Math.abs(restPI - (0.5 * Math.PI)) 
                / (0.5 * Math.PI) * 100).toFixed(15)} %`;
        }
    }

    // --- 3. グレゴリー・ライプニッツ級数 (π) の自己校正実験 ---
    output2.textContent = "=== Experiment: PI's Number (π) ===\nStep | 漸化式 PI      | 誤差(delta)     
        | 射影値(proj)    | ★推論値(rest)\n";


    // 外部のMath.Eを排除し、自身の振る舞いからdeltaを導出する
    let prev2PI4 = 1.0;
    let prevPI4 = 1.0;
    let estimatedDeltaPI4 = 1.0; // 最初は大きな誤差と仮定
    let restPI4;
    let pi4 = 0.0;
    let sign = 1.0;
    let gain = 1.0;
    let steps2 = 30;

    for (let n = 0; n <= steps2; n++) {
        // ここで pi4 * 4 が π の近似値になります
        pi4 += sign / (2.0 * n + 1.0);
        sign *= -1.0;

        // この estimatedDeltaPI4 を用いて射影を行う
        // これにより、Math.E を使わずに「自分の現在地」を測定できる
        let proj = pi4 * getInfiniteLogAxis(n, Range);

        //gainを調整して設定
        //gain = (proj / 8) * n * (50 / 11);
        gain = (proj / 5) * n * (18 / 7);

        // 符号が入れ替わるので2つ前のステップとの差を「現在の誤差の勢い」と定義する
        estimatedDeltaPI4 = sign * Math.abs(pi4 - prev2PI4) * gain;
    
        // rest の計算に、自身が導出した estimatedDeltaPI4 をフィードバックする
        restPI4 = restoredInfiniteLogAxis(pi4, proj, estimatedDeltaPI4);
    
        prev2PI4 = prevPI4;
        prevPI4 = pi4;

        output2.textContent += `${n.toString().padStart(4)} | ${(pi4 * 4).toFixed(12)} |  ${(Math.PI - pi4 * 4).toFixed(12)} 
            | ${proj.toFixed(12)} | ${(restPI4 * 4).toFixed(12)}\n`;
    }
    final2.innerText = `π: ${(restPI4 * 4).toFixed(15)}`;
    theory2.innerText = `π: ${Math.PI.toFixed(15)}`;
    delta2.innerText = `dπ: ${(Math.abs((restPI4 * 4) - Math.PI) / Math.PI * 100).toFixed(15)} %`;

}

3. まとめ

無限級数を無限回計算するという「到達不可能な物語」を追い続ける代わりに、
私は対数軸というレンズで無限を有限の空間へ射影しました。
これは、外部の近似値に依存せず、計算という自律的な反復の中で
真理を固定するための、私なりの数学的証明である。
ここでeの導出法通りにeを漸化的に求めています
e += 1.0 / factorial;
この漸化式は無限大まで進めることができてしまい
ある程度で計算の打ち切りをした近似計算になります
そこで無限対数軸を用いることで
極限を有限のステップで求めることができます

※このエンジンは、あなたが独自の漸化式をどう定義するかで、
全く異なる真理を映し出します。
そして漸化式の変化を検知して誤差を補正するので無限大まで計算しなければならない
定数決定を有限のステップで終了することに成功するでしょう

4. おまけ　グレゴリー・ライプニッツ級数の導出

15ステップ程度では極端に収束速度が遅いこの漸化式で本件の威力を確かめてみます
漸化式で符号が反転するのならば振動しつつ収束することになりますので
収束する値の見積もりは2値の平均(sn + sn-1) / 2あたりということになります
この情報をもとにgainを調整します

最終推論値:

理論値:

誤差率:


5. おまけ2　黄金比の漸化式の導出

黄金比の漸化式で本件の威力を確かめてみます
黄金比の漸化式
let A = 1.0;
let nextA = 1 + 1 / A;
A = nextA;

最終推論値: