跳轉到

6.2 判別法大全#

學習動機#

第 6.1 節定義了「收斂」，但立刻留下了一個實用問題：

面對一個具體的級數 \(\sum a_n\) ，我要怎麼知道它收斂？收斂到多少？

十七、十八世紀的答案是「靠眼睛看」：如果項衰减得夠快，看起來就會收斂。這種做法在 \(\sum \frac{1}{n^2}\) 上沒問題，但在 \(\sum \frac{1}{n \log n}\) 上就會出錯——它看起來也「很快」地變小，卻是發散的。十九世紀的數學家因此發展出一整套判別法：每一種判別法都是對「項衰减速度」的一次量化。

本章要清點的判別法有：

  1. 比較判別法（含極限比較）——把未知級數塞進已知級數的籠子裡；
  2. 比值判別法（d'Alembert, 1761）——看相鄰兩項的比值；
  3. 根式判別法（Cauchy, 1821）——看 \(n\) 次根；並說明它與比值判別法的等價形式；
  4. Raabe-Duhamel 判別法（Raabe, 1876）——比值判別法在 \(L = 1\) 附近的精密化；
  5. Bertrand 判別法——處理 \(\frac{1}{n^\alpha (\log n)^\beta}\) 型；
  6. Gauss 判別法——處理 \(a_n/a_{n+1} \to 1\) 但有 \(O(1/n)\) 修正的級數；
  7. 萊布尼茲交錯級數判別法（Leibniz, 1676）——處理交錯級數，並回顧萊布尼茲對 \(\ln 2\) 的錯算；
  8. 絕對收斂 vs 條件收斂的區分，以及判別法失效的案例。

這些判別法在本書中有一個共同特徵：它們全都只需要「相鄰項的比值」或「和已知級數比較」，因此全都非常適合用符號計算實作。SymPy 的 sp.limit 讓每一條判別法都變成三行程式碼。

6.2.1 比較判別法：把級數塞進籠子#

比較判別法（comparison test）是最古老也最萬用的判別法。

設 \(0 \le a_n \le b_n\) 對所有 \(n\) 成立。若 \(\sum b_n\) 收斂，則 \(\sum a_n\) 收斂。

證明只有一行： \(s_N^{(a)} \le s_N^{(b)}\) ，而右邊有界，所以左邊也有界（單調有界數列收斂，第 2 章的定理）。

極限比較判別法（limit comparison test）是它的加強版：

若 \(\lim_{n\to\infty} \frac{a_n}{b_n} = L\) ，其中 \(0 < L < \infty\) ，則 \(\sum a_n\) 與 \(\sum b_n\) 同時收斂或同時發散。

極限比較的優勢在於它不需要逐項不等式，只要一個極限值。

「已知級數」的倉庫裡，最基本的是 ** \(p\) -級數** \(\sum \frac{1}{n^p}\) ： \(p > 1\) 收斂、 \(p \le 1\) 發散。讓我們把這兩種判別法都做成 SymPy 函式。

import sympy as sp

n = sp.symbols('n', integer=True, positive=True)

def compare_test(a, b):
    """比較判別法：回傳 b_n - a_n，若 >= 0 則 a_n <= b_n。"""
    return sp.simplify(b - a)

def limit_compare(a, b):
    """極限比較判別法：回傳 lim a_n/b_n，落在 (0, inf) 則同斂同散。"""
    return sp.limit(sp.simplify(a / b), n, sp.oo)

# p-級數的收斂臨界點：lim 1/n^p 在 p=1 處是 1（無法判定）
for p in [sp.Rational(1, 2), 1, sp.Rational(3, 2), 2]:
    print(f"1/n^{p} 與 1/n^2 的極限比較 L =", limit_compare(1 / n**p, 1 / n**2))

print()
print("比較判別法：確認逐項不等式")
print("1/n^2 <= 1/n^1.5 ? 差 =", compare_test(1 / n**2, 1 / n**sp.Rational(3, 2)))
print("1/n   <= 1/n^2 ? 差 =", compare_test(1 / n, 1 / n**2))

預期輸出：

1/n^1/2 與 1/n^2 的極限比較 L = oo
1/n^1 與 1/n^2 的極限比較 L = oo
1/n^3/2 與 1/n^2 的極限比較 L = oo
1/n^2 與 1/n^2 的極限比較 L = 1

比較判別法：確認逐項不等式
1/n^2 <= 1/n^1.5 ? 差 = -1/n**2 + n**(-3/2)
1/n   <= 1/n^2 ? 差 = (1 - n)/n**2

注意 \(p\) 小於 \(2\) 時極限比較給出 oo （或 0 ）——這些都是「無法判定同斂同散」的訊號；只有 \(L \in (0, \infty)\) 才能下結論。這正是判別法的分界性質：它們只在兩側給出確定答案，中間那條細縫要靠更精密的判別法（Raabe、Bertrand）來填。

6.2.2 比值判別法（d'Alembert, 1761）#

比值判別法（ratio test, d'Alembert's test）：

令 \(L = \lim_{n\to\infty} \left| \frac{a_{n+1}}{a_n} \right|\) 。若 \(L < 1\) 則級數收斂；若 \(L > 1\) 則級數發散；若 \(L = 1\) 則無法判定。

這是最受歡迎的判別法，因為「相鄰項的比值」通常最容易算出來——尤其是當 \(a_n\) 是冪次、階乘、幾何因子等等的乘積時。

它的直覺是：如果每一步只保留原來的 \(L\) 倍，且 \(L < 1\) ，那麼項以等比速度衰减，總和被一個等比級數控制住。

根式判別法（root test, Cauchy 1821）：

令 \(L = \lim_{n\to\infty} |a_n|^{1/n}\) 。若 \(L < 1\) 則收斂；若 \(L > 1\) 則發散；若 \(L = 1\) 則無法判定。

根式判別法的直覺更簡單： \(|a_n|^{1/n}\) 是「 \(a_n\) 每一步開 \(n\) 次根」的衰減率。若衰減率小於 \(1\) ，則 \(a_n\) 衰減得比任何 \(n^{-p}\) 都快。

兩者的等價形式是這樣的：對正項級數，

\[ \lim_{n\to\infty} \sqrt[n]{a_n} = \lim_{n\to\infty} \frac{1}{\sqrt[n]{a_{n+1}/a_n}} \]

（這是 Stolz–Cesaro 定理的一個特例。）所以「比值判別」與「根式判別」在本質上是同一個判別法的兩種表述：比值判別法看一步的衰減率，根式判別法看平均衰減率。

讓我們把這三個判別法（比值、根式、以及它們的等價關係）都實作出來。

import sympy as sp

n = sp.symbols('n', integer=True, positive=True)

def ratio_test(a):
    """d'Alembert 比值判別法：L = lim |a_{n+1}/a_n|。"""
    return sp.limit(sp.simplify(a.subs(n, n + 1) / a), n, sp.oo)

def root_test(a):
    """Cauchy 根式判別法：L = lim |a_n|^(1/n)。"""
    return sp.limit(sp.simplify(sp.Abs(a) ** (sp.Rational(1, 1) / n)), n, sp.oo)

cases = [
    ("1/n**2", 1 / n**2),
    ("1/n", 1 / n),
    ("(1/2)**n / n**2", sp.Rational(1, 2)**n / n**2),
    ("(1/2)**n", sp.Rational(1, 2)**n),
    ("n!/3**n", sp.factorial(n) / 3**n),
]
for label, a in cases:
    print(f"a_n = {label}")
    print("   比值 L =", ratio_test(a))
    print("   根式 L =", root_test(a))

預期輸出：

a_n = 1/n**2
   比值 L = 1
   根式 L = 1
a_n = 1/n
   比值 L = 1
   根式 L = 1
a_n = (1/2)**n / n**2
   比值 L = 1/2
   根式 L = 1/2
a_n = (1/2)**n
   比值 L = 1/2
   根式 L = 1/2
a_n = n!/3**n
   比值 L = oo
   根式 L = oo

n!/3**n 那一行特別值得注意：比值 \(\frac{(n+1)!}{3^{n+1}} \cdot \frac{3^n}{n!} = \frac{n+1}{3} \to \infty\) ，所以級數發散（事實上項根本不會趨近 0）。SymPy 用 oo 忠實地回報了這一點。

6.2.3 Raabe-Duhamel 判別法（Raabe, 1876）#

比值判別法在 \(L = 1\) 時完全失效——而這恰恰是最常見的情形（所有 \(p\) -級數的比值極限都是 \(1\) ）。德國數學家 Otto Raabe 在 1876 年提出了二階精密化：

令 \(R = \lim_{n\to\infty} n \left( \left| \frac{a_n}{a_{n+1}} \right| - 1 \right)\) 。若 \(R > 1\) 則收斂；若 \(R < 1\) 則發散；若 \(R = 1\) 仍無法判定。

直覺：當比值極限是 \(1\) 時，光看「一步」不夠，要看誤差項的階。若 \(\frac{a_n}{a_{n+1}} = 1 + \frac{R}{n} + o(1/n)\) ，則 \(a_n \sim C n^{-R}\) ——這正好回到 \(p\) -級數的臨界點 \(p = 1\) ！

Raabe 判別法與 Bertrand 判別法在文獻中常被混稱為「Raabe-Duhamel 判別法」（Duhamel 是 1867 年獨立給出同樣結果的人）。

import sympy as sp

n = sp.symbols('n', integer=True, positive=True)

def raabe_test(a):
    """Raabe-Duhamel 判別法：R = lim n(|a_n/a_{n+1}| - 1)。"""
    return sp.limit(sp.simplify(n * (a / a.subs(n, n + 1) - 1)), n, sp.oo)

cases = [
    ("1/n**2", 1 / n**2),
    ("1/n", 1 / n),
    ("1/n^1.5", 1 / n**sp.Rational(3, 2)),
    ("(1/2)**n / n**2", sp.Rational(1, 2)**n / n**2),
    ("1/(n*log(n))", 1 / (n * sp.log(n))),
]
for label, a in cases:
    R = raabe_test(a)
    verdict = "收斂" if R > 1 else ("發散" if R < 1 else "無法判定")
    print(f"a_n = {label:22s}  Raabe R = {R}  ->  {verdict}")

預期輸出：

a_n = 1/n**2                  Raabe R = 2  ->  收斂
a_n = 1/n                     Raabe R = 1  ->  無法判定
a_n = 1/n^1.5                 Raabe R = 3/2  ->  收斂
a_n = (1/2)**n / n**2         Raabe R = oo  ->  收斂
a_n = 1/(n*log(n))            Raabe R = 1  ->  無法判定

Raabe 判別法成功地把「比值判別法無法判定」的 \(\sum \frac{1}{n^2}\) 判成收斂（ \(R = 2 > 1\) ），但對 \(\sum \frac{1}{n}\) 仍然無能為力（ \(R = 1\) ）。這是判別法的階層性：每一層只比前一層多走一小步。

6.2.4 Bertrand 判別法：對數因子的出現#

再往前走一步： \(\sum \frac{1}{n (\log n)^\beta}\) 這類級數。它們的 Raabe 值仍然是 \(1\) ，所以 Raabe 判別法也失效。Henri Bertrand 的觀察是：對這類級數，關鍵不是 \(\frac{1}{n}\) 的指數，而是對數因子的冪次。

形式上，若

\[ a_n \sim \frac{C}{n^\alpha (\log n)^\beta} \]

則 \(\sum a_n\) 收斂當且僅當 \(\alpha > 1\) ，或 \(\alpha = 1\) 且 \(\beta > 1\) 。這可以從積分判別法直接得到（第 12 章會正式處理）： \(\int \frac{dx}{x^\alpha (\log x)^\beta}\) 的斂散完全由這兩個參數決定。

用 SymPy 我們可以把 \(\alpha\) 與 \(\beta\) 從級數中「挖」出來：

\[ \alpha = \lim_{n\to\infty} \frac{\log(1/a_n)}{\log n}, \qquad \beta = \lim_{n\to\infty} \frac{\log(1/a_n) - \alpha \log n}{\log \log n} \]
import sympy as sp

n = sp.symbols('n', integer=True, positive=True)

def bertrand_alpha(term):
    """從 a_n ~ C n^{-alpha} (log n)^{-beta} 抽出 alpha。"""
    return sp.limit(sp.simplify(sp.log(1 / term) / sp.log(n)), n, sp.oo)

def bertrand_beta(term, alpha):
    """從 a_n ~ C n^{-alpha} (log n)^{-beta} 抽出 beta。"""
    return sp.limit(
        sp.simplify((sp.log(1 / term) - alpha * sp.log(n)) / sp.log(sp.log(n))),
        n, sp.oo)

cases = [
    ("1/n**2", 1 / n**2),
    ("1/n", 1 / n),
    ("1/n^1.5", 1 / n**sp.Rational(3, 2)),
    ("1/(n*log(n))", 1 / (n * sp.log(n))),
    ("1/(n*log(n)**2)", 1 / (n * sp.log(n)**2)),
]
for label, term in cases:
    alpha = bertrand_alpha(term)
    beta = bertrand_beta(term, alpha)
    if alpha > 1:
        verdict = "收斂"
    elif alpha < 1:
        verdict = "發散"
    else:
        verdict = "收斂" if beta > 1 else "發散"
    print(f"a_n = {label:20s}  alpha = {alpha}  beta = {beta}  ->  {verdict}")

預期輸出：

a_n = 1/n**2                alpha = 2  beta = 0  ->  收斂
a_n = 1/n                   alpha = 1  beta = 0  ->  發散
a_n = 1/n^1.5               alpha = 3/2  beta = 0  ->  收斂
a_n = 1/(n*log(n))          alpha = 1  beta = 1  ->  發散
a_n = 1/(n*log(n)**2)       alpha = 1  beta = 2  ->  收斂

這兩列的對照是整章最漂亮的一張表： \(\frac{1}{n \log n}\) 與 \(\frac{1}{n (\log n)^2}\) 只差一個對數的平方，卻是發散與收斂之別。而 \(\frac{1}{n}\) 與 \(\frac{1}{n^{3/2}}\) 只差指數的半格，也是發散與收斂之別。收斂是極其脆弱的性質——這正是我們需要一整箱判別法的原因。

6.2.5 Gauss 判別法#

最後一個「比值型」判別法。當比值極限為 \(1\) 但不是 \(1 + \frac{R}{n}\) 的形式（而是更一般的有理函數型）時，Gauss 判別法接手：

設存在常數 \(\alpha, \beta\) 使得 \(\frac{a_n}{a_{n+1}} = \frac{n + \alpha}{n + \beta} + O\left(\frac{1}{n^2}\right)\) 。若 \(\beta - \alpha > 1\) 則收斂；若 \(\beta - \alpha < 1\) 則發散；若 \(\beta - \alpha = 1\) 則無法判定。

注意：Gauss 判別法的條件「 \(\frac{a_n}{a_{n+1}} = \frac{n+\alpha}{n+\beta} + O(1/n^2)\) 」正是「比值可以寫成有理函數」的更嚴格版本，所以它比 Raabe 判別法更精密（Raabe 只看 \(\frac{1}{n}\) 那一項）。但它能處理的級數類型也更窄（必須是超幾何型）。

典型例子是中心二項係數 \(\frac{\binom{2n}{n}}{4^n} \sim \frac{1}{\sqrt{\pi n}}\) ——比值 \(\frac{2(n+1)}{2n+1} = 1 + \frac{1}{2n} + O(1/n^2)\) ，屬於 \(\alpha = 1, \beta = 2\) 型， \(\beta - \alpha = 1\) ，正好卡在臨界點上（事實上這個級數發散，因為它 \(\sim 1/\sqrt{\pi n}\) ）。

import sympy as sp

n = sp.symbols('n', integer=True, positive=True)
al, be = sp.symbols('alpha beta', real=True)

# 通用的 Gauss 型：a_n = Gamma(n+alpha)/Gamma(n+beta)
a = sp.gamma(n + al) / sp.gamma(n + be)
print("a_n = Gamma(n+alpha)/Gamma(n+beta)")
print("   a_n/a_{n+1} =", sp.simplify(a / a.subs(n, n + 1)))
print("   Gauss 的 beta - alpha =", sp.limit(
    sp.simplify(n * (a / a.subs(n, n + 1) - 1)), n, sp.oo))

print()
# 具體例子：中心二項係數（卡在臨界點）
c = sp.binomial(2 * n, n) / 4**n
print("a_n = binom(2n,n)/4^n")
print("   a_n/a_{n+1} =", sp.simplify(c / c.subs(n, n + 1)))
print("   Gauss 的 beta - alpha =", sp.limit(
    sp.simplify(n * (c / c.subs(n, n + 1) - 1)), n, sp.oo))
print("   實際收斂？", sp.Sum(c, (n, 1, sp.oo)).is_convergent())

print()
# 另一個例子：Gamma(n)/Gamma(n+2) = 1/(n(n+1))，beta - alpha = 2 > 1
g = sp.gamma(n) / sp.gamma(n + 2)
print("a_n = Gamma(n)/Gamma(n+2) = 1/(n(n+1))")
print("   a_n/a_{n+1} =", sp.simplify(g / g.subs(n, n + 1)))
print("   Gauss 的 beta - alpha =", sp.limit(
    sp.simplify(n * (g / g.subs(n, n + 1) - 1)), n, sp.oo))
print("   實際收斂？", sp.Sum(g, (n, 1, sp.oo)).is_convergent())

預期輸出：

a_n = Gamma(n+alpha)/Gamma(n+beta)
   a_n/a_{n+1} = (beta + n)/(alpha + n)
   Gauss 的 beta - alpha = -alpha + beta

a_n = binom(2n,n)/4^n
   a_n/a_{n+1} = 2*(n + 1)/(2*n + 1)
   Gauss 的 beta - alpha = 1/2
   實際收斂？ False

a_n = Gamma(n)/Gamma(n+2) = 1/(n(n+1))
   a_n/a_{n+1} = (n + 2)/n
   Gauss 的 beta - alpha = 2
   實際收斂？ True

注意第一個例子的 \(\beta - \alpha\) 與 Raabe 判別法的 \(R\) 是同一個量——這不是巧合：Gauss 型級數正是 Raabe 判別法能完全解決的那一類。

6.2.6 萊布尼茲交錯級數判別法（Leibniz, 1676）#

到此為止的判別法都要求級數的項同號（或至少絕對值可控）。但有一大類級數是交錯的，例如 \(\sum \frac{(-1)^{n+1}}{n}\) 。對它們有一套專門的判別法：

萊布尼茲判別法（Leibniz criterion）：若 \(a_n \ge 0\) 、 \(a_n\) 單調遞減、且 \(a_n \to 0\) ，則交錯級數 \(\sum (-1)^{n+1} a_n\) 收斂。

而且它給出誤差估計：若 \(S\) 是其和、 \(S_N\) 是第 \(N\) 項部分和，則

\[ |S - S_N| \le a_{N+1} \]

歷史：萊布尼茲對 \(\ln 2\) 的錯算#

這裡有一個精彩的歷史故事。1676 年，萊布尼茲用級數

\[ \log 2 = 1 - \frac{1}{2} + \frac{1}{3} - \frac{1}{4} + \frac{1}{5} - \cdots \]

計算 \(\ln 2\) 。他得到的是正確的數值，但論證是不嚴謹的：他從 \(\frac{1}{1+x} = 1 - x + x^2 - x^3 + \cdots\) 出發，把 \(x = 1\) 代進去。這個代入恰好落在收斂區的邊界 \(|x| = 1\) 上——等比級數在 \(x = 1\) 處並不收斂（它是 \(1 - 1 + 1 - 1 + \cdots\) ，見 6.1.2 的 Grandi 級數），萊布尼茲當時並沒有能力說清楚「為什麼代入 \(x = 1\) 仍然給出了對的答案」。他只是「看起來」數字對就接受了。

同一篇論文（De seriebus infinitis earumque summa, 1676）裡，萊布尼茲也把這套「形式移位」的手法用在了真正發散的級數上：由 \(1 - 1 + 1 - 1 + \cdots = 1 - (1 - 1 + 1 - \cdots)\) 得到 \(\frac{1}{2}\) ，並且用同類的「對消」運算去處理 \(\sum \frac{1}{n}\) 這類發散級數——形式上做著與歐拉完全相同的無效操作。

修正由柯西在 1821 年完成：把「收斂」定義為「部分和數列有極限」，並由萊布尼茲判別法保證交錯級數的合法性。讓我們用 SymPy 把這個誤差界親手驗證一遍——這也正好是 5.3 節末尾提到的那個「交錯級數界」的正式版本。

import sympy as sp

n = sp.symbols('n', integer=True, positive=True)
N = sp.symbols('N', integer=True, positive=True)

# (1) 萊布尼茲的目標：ln 2 = 1 - 1/2 + 1/3 - 1/4 + ...
print("sum (-1)^(n+1)/n =", sp.summation((-1)**(n + 1) / n, (n, 1, sp.oo)))
print("sum 1/2^(n-1)   =", sp.summation(sp.Rational(1, 2)**(n - 1), (n, 1, sp.oo)))
print("sum 1/n (發散!)  =", sp.summation(1 / n, (n, 1, sp.oo)))

# (2) 萊布尼茲判別法的兩個前提：a_n 遞減、a_n -> 0
a = 1 / n
print()
print("a_n - a_{n+1} =", sp.simplify(a - a.subs(n, n + 1)))
print("lim a_n       =", sp.limit(a, n, sp.oo))

# (3) 誤差界 |S - S_N| <= a_{N+1}
print()
for M in [10, 100, 1000]:
    S_M = sp.summation((-1)**(n + 1) / n, (n, 1, M))
    err = abs(sp.N(sp.log(2) - S_M))
    bound = sp.N(1 / (M + 1))
    print(f"M={M:5d}  |誤差| = {err:.10f}   上界 a_(M+1) = {bound:.10f}   界成立? {err <= bound}")

預期輸出：

sum (-1)^(n+1)/n = log(2)
sum 1/2^(n-1)   = 2
sum 1/n (發散!)  = oo

a_n - a_{n+1} = 1/(n*(n + 1))
lim a_n       = 0

M=   10  |誤差| = 0.0475122599   上界 a_(M+1) = 0.0909090909   界成立? True
M=  100  |誤差| = 0.0049750012   上界 a_(M+1) = 0.0099009901   界成立? True
M= 1000  |誤差| = 0.0004997500   上界 a_(M+1) = 0.0009990010   界成立? True

注意誤差界的鬆緊：實際誤差只有上界的一半左右（因為誤差在兩個相鄰部分和之間來回擺動）。這也解釋了 5.3 節的痛點——交錯級數界要求 \(N \ge 1/\varepsilon\) 項才能達到精度 \(\varepsilon\) 。要把 \(\ln 2\) 算到小數點後 15 位，需要 \(10^{15}\) 項！

6.2.7 絕對收斂與條件收斂#

把所有判別法串起來之後，有一個分類問題浮上水面。對一個收斂級數 \(\sum a_n\) ，考慮它的「絕對值級數」 \(\sum |a_n|\) ：

  • 若 \(\sum |a_n|\) 也收斂，則 \(\sum a_n\) 稱為絕對收斂（absolutely convergent）；
  • 若 \(\sum a_n\) 收斂但 \(\sum |a_n|\) 發散，則稱為條件收斂（conditionally convergent）。

這個區分之所以重要，是因為第 6.1.4 節的 Riemann 重排定理只對條件收斂級數成立：絕對收斂級數的和與排列順序無關（這是 19 世紀末才被嚴格證明的定理），而條件收斂級數的和可以被重排成任意實數。

用 SymPy 判定這三種狀態（收斂 / 發散 / 條件收斂）非常直接：Sum.is_convergent() 與 Sum.is_absolutely_convergent() 兩個方法。

import sympy as sp

n = sp.symbols('n', integer=True, positive=True)

def classify(term, limits=(n, 1, sp.oo)):
    """把級數分類成 收斂（絕對）/ 條件收斂 / 發散。"""
    S = sp.Sum(term, limits)
    conv = S.is_convergent()
    if conv is None:
        return "無法判定"
    if not bool(conv):
        return "發散"
    abs_conv = S.is_absolutely_convergent()
    if abs_conv is None:
        return "收斂（絕對性未知）"
    return "收斂（絕對）" if bool(abs_conv) else "條件收斂"

cases = [
    ("1/n**2", 1 / n**2),
    ("(-1)^(n+1)/n**2", (-1)**(n + 1) / n**2),
    ("(-1)^(n+1)/n", (-1)**(n + 1) / n),
    ("1/n", 1 / n),
    ("2**n", 2**n),
]
for label, term in cases:
    print(f"sum {label:20s} -> {classify(term)}")

預期輸出：

sum 1/n**2               -> 收斂（絕對）
sum (-1)^(n+1)/n**2      -> 收斂（絕對）
sum (-1)^(n+1)/n         -> 條件收斂
sum 1/n                  -> 發散
sum 2**n                 -> 發散

6.2.8 判別法失效的案例： \(1/(n \log n)\) 型#

最後，讓我們把本章所有的判別法同時丟到一個級數上，看看它們的無能為力。這是本章最重要的一課。

考慮級數

\[ \sum_{n=2}^{\infty} \frac{1}{n (\log n)^p} \]

由 Bertrand 判別法我們知道： \(p > 1\) 收斂、 \(p \le 1\) 發散。但比值判別法、根式判別法、Raabe 判別法全部給出 \(L = 1\) 或 \(R = 1\) ——它們在這裡一律失效！

這是因為對數因子 \(\log n\) 增長得比任何冪次都慢： \(n^{-\varepsilon} \ll (\log n)^{-\beta}\) 對任何 \(\varepsilon, \beta > 0\) 都成立。所以任何只看「多項式階」的判別法都看不見它。

import sympy as sp

n = sp.symbols('n', integer=True, positive=True)

def ratio_test(a):
    return sp.limit(sp.simplify(a.subs(n, n + 1) / a), n, sp.oo)

def root_test(a):
    return sp.limit(sp.simplify(sp.Abs(a) ** (sp.Rational(1, 1) / n)), n, sp.oo)

def raabe_test(a):
    return sp.limit(sp.simplify(n * (a / a.subs(n, n + 1) - 1)), n, sp.oo)

print("對數型級數：古典判別法全部失效")
for p in [1, 2, 3]:
    a = 1 / (n * sp.log(n)**p)
    print(f"a_n = 1/(n log(n)^{p})")
    print("   比值 L =", ratio_test(a))
    print("   根式 L =", root_test(a))
    print("   Raabe R =", raabe_test(a))
    print("   真相（SymPy 直接判定）:", sp.Sum(a, (n, 2, sp.oo)).is_convergent())

預期輸出：

對數型級數：古典判別法全部失效
a_n = 1/(n log(n)^1)
   比值 L = 1
   根式 L = 1
   Raabe R = 1
   真相（SymPy 直接判定）: False
a_n = 1/(n log(n)^2)
   比值 L = 1
   根式 L = 1
   Raabe R = 1
   真相（SymPy 直接判定）: True
a_n = 1/(n log(n)^3)
   比值 L = 1
   根式 L = 1
   Raabe R = 1
   真相（SymPy 直接判定）: True

這就是第 12 章的入口。對這類級數，古典判別法全部失效，正確的工具是積分判別法（把 \(\sum a_n\) 換成 \(\int a(x)\,dx\) 來比較），而積分判別法在第 12 章會以 Lebesgue 積分的語言重新出現。順帶一提，SymPy 自己的 is_convergent() 之所以能判定這些級數，正是因為它在背後內建了積分判別法。

本章的教訓：判別法不是「對或錯」的問題，而是「覆蓋範圍」的問題。每一種判別法都是一張網，只撈特定形狀的魚。 \(\sum \frac{1}{n (\log n)^p}\) 這一族魚，需要積分判別法這張更大的網。

習題#

習題 6.2.1（比較判別法與 \(p\) -級數） (a) 對 \(a_n = \frac{1}{n^{3/2}} + \frac{1}{n^2}\) 用極限比較找出它對應的 \(p\) -級數，並用 SymPy 驗證收斂。 (b) 對 \(a_n = \frac{1}{\sqrt{n} + n}\) 同樣處理，並解釋為什麼「兩項相加」不改變收斂性。 (c) 證明：若 \(\lim \frac{a_n}{b_n} = 0\) 且 \(\sum b_n\) 收斂，則 \(\sum a_n\) 收斂。用 SymPy 舉一個具體例子。

習題 6.2.2（比值與根式的等價性） (a) 對 \(a_n = \frac{1}{n!} + \frac{1}{2^n}\) 同時計算比值極限與根式極限，說明兩者相等的原因。 (b) 證明根式判別法與比值判別法的等價形式： \(\lim \sqrt[n]{a_n} = \lim \frac{1}{\sqrt[n]{a_{n+1}/a_n}}\) （用 Stolz–Cesaro 定理），並對具體級數用 SymPy 驗證。 (c) 找一個比值極限存在但根式極限不存在的級數（提示：考慮分塊構造的級數），說明為什麼這會讓「等價形式」只在極限存在時才成立。

習題 6.2.3（Raabe 與 Bertrand 的分工） (a) 對 \(a_n = \frac{1}{n^p \log n}\) （ \(p > 0\) 任意），用 Raabe 判別法與 Bertrand 判別法分別判定，說明兩者都失敗的原因。 (b) 對 \(a_n = \frac{1}{n (\log n)^p}\) 用 Bertrand 判別法抽取 \(\alpha, \beta\) ，並用 SymPy 的 is_convergent() 核對結論。 (c) 用 Bertrand 判別法證明： \(\sum \frac{1}{n (\log n)^p}\) 收斂當且僅當 \(p > 1\) 。

習題 6.2.4（Gauss 判別法） (a) 對 \(a_n = \frac{1}{\binom{2n}{n}}\) 計算 \(\frac{a_n}{a_{n+1}}\) ，用 Gauss 判別法判定斂散，並與 SymPy 的 is_convergent() 核對。 (b) 對 \(a_n = \frac{n!}{n^n \sqrt{n}}\) 同樣處理，說明為什麼它的 \(\beta - \alpha\) 恰好等於臨界值。 (c) 說明 Gauss 判別法的適用範圍（超幾何型）比 Raabe 判別法窄，但精度高，並舉一個 Raabe 能判而 Gauss 不能判的例子。

習題 6.2.5（萊布尼茲判別法與 \(\ln 2\) ） (a) 用 SymPy 驗證交錯級數的誤差界 \(|S - S_N| \le a_{N+1}\) 在 \(\sum \frac{(-1)^{n+1}}{n}\) 與 \(\sum \frac{(-1)^{n+1}}{\sqrt{n}}\) 上都成立（後者用積分判別法判定收斂，但誤差界仍由萊布尼茲判別法給出）。 (b) 計算 \(\sum \frac{(-1)^{n+1}}{\sqrt{n}}\) 的部分和，觀察它收斂到多慢，並與 \(\sum \frac{(-1)^{n+1}}{n}\) 比較。 (c) 用第 5.3 節的變換 \(\ln 2 = 2\operatorname{arctanh}(1/3)\) 重寫，並計算要達到 \(10^{-10}\) 精度各需要多少項，說明為什麼萊布尼茲當年「算對了」卻「推導錯了」。