Giải phương trình bậc năm bằng Python: phần dư nhỏ, nghiệm vẫn sai

Giải phương trình bậc năm bằng Python: phần dư nhỏ, nghiệm vẫn sai

Để giải phương trình bậc năm bằng Python, có thể truyền hệ số cho numpy.roots hoặc dùng sympy.nroots khi cần điều khiển độ chính xác. Nhưng kiểm tra riêng phần dư $|P(z)|$ chưa đủ để biết nghiệm gần đúng $z$ cách nghiệm thật bao xa.

Trong thí nghiệm dưới đây, đa thức có năm nghiệm thực đã biết. Khi ba nghiệm nằm cách nhau $10^{-6}$, NumPy trả về một cặp nghiệm phức và sai số nghiệm lớn nhất khoảng $7{,}67\times10^{-6}$, dù phần dư lớn nhất chỉ khoảng $1{,}07\times10^{-13}$. Tăng độ chính xác tính toán giúp ích khi hệ số đầu vào được giữ chính xác; nó không khôi phục thông tin đã mất khi làm tròn hệ số.

Tạo phương trình có ba nghiệm nằm sát nhau

Ta dùng một họ đa thức bậc năm với tham số dương $\delta$:

$$ P_\delta(x)=(x+2)(x-3)\left((x-1)^3-\delta^2(x-1)\right). $$

Năm nghiệm chính xác là $-2$, $1-\delta$, $1$, $1+\delta$ và $3$. Với $\delta>0$ trong ba cấu hình thử, chúng đều là nghiệm đơn. Khi $\delta$ tiến về 0, ba nghiệm giữa cùng tiến đến nghiệm bội ba tại 1. Đây là ý nghĩa của “nghiệm gần bội” trong bài.

Mã tạo hệ số bằng số hữu tỉ chính xác, sau đó truyền đa thức đã khai triển cho bộ giải. Các nhân tử đã biết chỉ giúp xây dữ liệu kiểm chứng và nghiệm chuẩn; chương trình không dùng chúng để thay thế bước giải số.

Việc chọn một đa thức dễ phân tích không mâu thuẫn với giới hạn của công thức nghiệm bậc năm. Không có công thức chỉ dùng các phép toán và căn thức áp dụng cho mọi phương trình bậc năm tổng quát; từng phương trình riêng vẫn có thể có nghiệm hữu tỉ hoặc biểu thức căn thức. Phần nền tảng có trong bài Lý thuyết Galois và công thức nghiệm bậc năm.

Tách ba cách tính để biết sai số đến từ đâu

Thí nghiệm chạy với $\delta$ lần lượt bằng $10^{-2}$, $10^{-4}$ và $10^{-6}$. Mỗi đa thức được giải theo ba cách:

Nhãn trong kết quả Hệ số đầu vào Bộ giải
numpy_float64 Làm tròn thành float64 np.roots
sympy_exact_60 Hữu tỉ chính xác từ đầu sp.nroots(..., n=60, maxsteps=300)
sympy_rounded_60 Giá trị nhị phân đã làm tròn của cùng mảng float64, chuyển thành hữu tỉ chính xác sp.nroots(..., n=60, maxsteps=300)

numpy.roots nhận hệ số theo thứ tự từ lũy thừa cao nhất xuống hằng số và tính trị riêng của ma trận companion. Đây là API đa thức cũ của NumPy; bài giữ nguyên API này để phép thử có quy ước đầu vào rõ ràng. Tài liệu numpy.roots 2.2

Hai hàng SymPy cùng đặt n=60, tức yêu cầu độ chính xác thập phân 60 chữ số cho phép giải số. Số chữ số yêu cầu không phải chứng nhận sai số cho mọi đa thức. Tài liệu cũng lưu ý nroots có thể gặp khó với đa thức có điều kiện số kém. Hướng dẫn tìm nghiệm đa thức của SymPy

Trong nhánh sympy_rounded_60, lệnh sp.Rational(float(c)) giữ chính xác giá trị float đã nhận. Nó không đoán lại phân số ban đầu. Vì vậy, so sánh hai nhánh SymPy giúp nhìn thấy tác động của dữ liệu đầu vào ngay cả khi đã tăng độ chính xác phép tính. SymPy khuyến nghị dùng chuỗi hoặc Rational từ đầu nếu cần tránh sai số khởi tạo từ Python float. Hướng dẫn số dấu phẩy động của SymPy

Đo sai số nghiệm và phần dư riêng biệt

Bộ giải có thể trả nghiệm theo thứ tự khác nhau, nên mã thử tất cả 120 cách ghép một-một giữa năm nghiệm tính được và năm nghiệm chuẩn. Sai số nghiệm lớn nhất là giá trị nhỏ nhất của sai số lớn nhất trong các cách ghép đó. Phép ghép dùng khoảng cách phức và giữ nguyên phần ảo.

Phần dư lớn nhất là giá trị lớn nhất của $|P_\delta(z)|$ tại năm nghiệm tính được, luôn dùng hệ số hữu tỉ của đa thức mục tiêu ban đầu. Đặc biệt, phần dư của nhánh sympy_rounded_60 vẫn được đo trên đa thức mục tiêu, không phải chỉ trên đa thức đã làm tròn mà nhánh đó đang giải.

Mã đánh giá các chỉ số bằng mpmath với mp.dps=80. Cách này giảm ảnh hưởng của triệt tiêu số học trong chính bước kiểm tra phần dư, so với thế nghiệm lại bằng float64. Đây vẫn là đánh giá số hữu hạn, không phải một chứng minh bằng số học khoảng. Độ chính xác làm việc trong mpmath

$\delta$ Phương pháp Sai số nghiệm lớn nhất Phần dư lớn nhất
$10^{-2}$ NumPy float64 5,758283e-12 1,199028e-13
$10^{-2}$ SymPy, hệ số chính xác, 60 chữ số 6,223015e-63 7,479940e-66
$10^{-2}$ SymPy, hệ số đã làm tròn, 60 chữ số 3,349033e-12 8,069053e-15
$10^{-4}$ NumPy float64 5,836112e-8 1,065814e-13
$10^{-4}$ SymPy, hệ số chính xác, 60 chữ số 6,994669e-62 8,393463e-69
$10^{-4}$ SymPy, hệ số đã làm tròn, 60 chữ số 1,379006e-8 1,290159e-15
$10^{-6}$ NumPy float64 7,667662e-6 1,065814e-13
$10^{-6}$ SymPy, hệ số chính xác, 60 chữ số 3,197136e-62 3,836564e-73
$10^{-6}$ SymPy, hệ số đã làm tròn, 60 chữ số 5,074875e-6 3,729687e-15

Các giá trị là kết quả thực chạy của cấu hình ghi dưới đây, đã làm tròn khi trình bày. Đây là sai số tuyệt đối. Phần dư tuyệt đối phụ thuộc thang của đa thức: nhân mọi hệ số với một hằng số sẽ đổi phần dư mà không đổi nghiệm. Phép thử giữ hệ số đầu bằng 1 cho cả ba cấu hình.

Khi khoảng cách giữa ba nghiệm giữa giảm từ $10^{-2}$ xuống $10^{-6}$, sai số nghiệm NumPy tăng rõ trong lượt chạy này, còn phần dư vẫn cỡ $10^{-13}$. Với cấu hình khó nhất, chênh lệch hệ số lớn nhất do chuyển sang float64 chỉ khoảng 1,331854e-15, nhưng nhánh SymPy giải các hệ số đó ở 60 chữ số vẫn lệch nghiệm chuẩn khoảng 5,074875e-6. Nhánh hệ số hữu tỉ chính xác tránh được nguồn nhiễu đầu vào ấy.

Vì sao phần dư nhỏ chưa đủ?

Ngay tại nghiệm giữa, ta tính được:

$$ P'_\delta(1)=6\delta^2. $$

Khi $\delta$ nhỏ, đồ thị rất phẳng gần nghiệm 1. Với một nghiệm đơn $r$ và sai lệch đủ nhỏ $e$, khai triển Taylor cho $P(r+e)\approx P'(r)e$. Một giá trị hàm nhỏ vì thế có thể tương ứng với sai lệch vị trí đáng kể khi đạo hàm nhỏ. Xấp xỉ này mang tính cục bộ; không dùng nó làm chặn sai số khi sai lệch đã lớn so với khoảng cách giữa các nghiệm.

Ở $\delta=10^{-6}$, ba nghiệm mục tiêu gần 1 là 0.999999, 1 và 1.000001. Cụm kết quả NumPy trong lượt chạy là:

10.999996133647 - 0.000006621507225334j
20.999996133647 + 0.000006621507225334j
31.000007732706

Không nên tự bỏ phần ảo bằng .real để biến kết quả này thành ba nghiệm thực “đúng”. Phần ảo lớn nhất còn lớn hơn khoảng cách $10^{-6}$ đang cần phân biệt. Bài Số phức và biểu diễn phần thực, phần ảo cung cấp nền tảng để đọc loại kết quả đó.

Nhánh sympy_rounded_60 cũng trả một cặp phức, với độ lớn phần ảo khoảng 4,366442e-6. Ta đã đưa cho nó một đa thức có hệ số khác đa thức mục tiêu. Kết quả này cho thấy tăng precision sau bước làm tròn không đủ để tái tạo năm nghiệm thực ban đầu.

Mã chạy lại thí nghiệm

Lần chạy dùng Python 3.10.11, NumPy 2.2.5, SymPy 1.14.0 và mpmath 1.3.0 trên macOS arm64. Dữ liệu được tạo xác định bằng số hữu tỉ, không dùng ngẫu nhiên nên không có seed. Kết quả chi tiết của NumPy có thể thay đổi theo phiên bản và thư viện đại số tuyến tính.

Tạo môi trường riêng, cài các phiên bản và lưu phần Python sau thành experiment.py:

1python3 -m venv .venv
2source .venv/bin/activate
3python -m pip install 'numpy==2.2.5' 'sympy==1.14.0' 'mpmath==1.3.0'
4python experiment.py
 1from itertools import permutations
 2import platform
 3
 4import mpmath as mp
 5import numpy as np
 6import sympy as sp
 7
 8SOLVER_DIGITS = 60
 9CHECK_DIGITS = 80
10MAX_STEPS = 300
11
12
13def rational_to_mp(value):
14    value = sp.Rational(value)
15    return mp.mpf(int(value.p)) / int(value.q)
16
17
18def sympy_to_mp(value):
19    real, imag = value.as_real_imag()
20    return mp.mpc(str(real.evalf(75)), str(imag.evalf(75)))
21
22
23def measure(roots, truth, coefficients):
24    # Match all five roots bijectively; retain every imaginary part.
25    error = min(max(abs(z - r) for z, r in zip(roots, order))
26                for order in permutations(truth))
27    residual = max(abs(mp.polyval(coefficients, z)) for z in roots)
28    imaginary = max(abs(z.imag) for z in roots)
29    return error, residual, imaginary
30
31
32def main():
33    mp.mp.dps = CHECK_DIGITS
34    print(f"Python {platform.python_version()} | NumPy {np.__version__} | "
35          f"SymPy {sp.__version__} | mpmath {mp.__version__} | {platform.machine()}")
36    print(f"nroots digits={SOLVER_DIGITS}, maxsteps={MAX_STEPS}, "
37          f"check digits={CHECK_DIGITS}; deterministic, no random seed")
38    x = sp.symbols("x")
39    for denominator in (100, 10_000, 1_000_000):
40        delta = sp.Rational(1, denominator)
41        exact_roots = [-2, 1 - delta, 1, 1 + delta, 3]
42        polynomial = sp.Poly(sp.prod(x - r for r in exact_roots), x)
43        coefficients = polynomial.all_coeffs()  # Highest power first.
44        floats = np.array([float(c) for c in coefficients], dtype=np.float64)
45        rounded = sp.Poly.from_list([sp.Rational(float(c)) for c in floats], x)
46        reference = [rational_to_mp(r) for r in exact_roots]
47        check_coefficients = [rational_to_mp(c) for c in coefficients]
48        perturbation = max(abs(mp.mpf(float(c)) - original)
49                           for c, original in zip(floats, check_coefficients))
50        cases = [
51            ("numpy_float64", [mp.mpc(float(z.real), float(z.imag))
52                               for z in np.roots(floats)]),
53            ("sympy_exact_60", [sympy_to_mp(z) for z in sp.nroots(
54                polynomial, n=SOLVER_DIGITS, maxsteps=MAX_STEPS)]),
55            ("sympy_rounded_60", [sympy_to_mp(z) for z in sp.nroots(
56                rounded, n=SOLVER_DIGITS, maxsteps=MAX_STEPS)]),
57        ]
58        print(f"\ndelta=1/{denominator}")
59        print("coefficients:", coefficients)
60        print("max_coefficient_rounding:", mp.nstr(perturbation, 7))
61        print("method | max_root_error | max_target_residual | max_abs_imag")
62        for name, roots in cases:
63            assert len(roots) == 5 and all(mp.isfinite(abs(z)) for z in roots)
64            metrics = measure(roots, reference, check_coefficients)
65            print(name + " | " + " | ".join(mp.nstr(v, 7) for v in metrics))
66            if name == "sympy_exact_60":
67                assert metrics[0] < mp.mpf("1e-59")
68            if denominator == 1_000_000:
69                cluster = sorted((z for z in roots if abs(z - 1) < mp.mpf("0.01")),
70                                 key=lambda z: (z.real, z.imag))
71                print("cluster:", "; ".join(mp.nstr(z, 13) for z in cluster))
72
73
74if __name__ == "__main__":
75    main()

Khi dùng với đa thức chưa biết nghiệm chuẩn

Trong bài, nghiệm thật được biết trước để đo trực tiếp sai số. Với bài toán thực, có thể bắt đầu bằng kiểm tra thứ tự và nguồn gốc hệ số, giữ dữ liệu chính xác nếu mô hình cho phép, rồi so sánh kết quả khi tăng precision. Đồng thời kiểm tra phần dư theo thang phù hợp và độ tách giữa các nghiệm. Kết quả ổn định qua hai mức precision là một tín hiệu kiểm tra, chưa phải chứng nhận toán học.

Nếu cần xác định chắc nghiệm nào là thực hoặc gặp lỗi hội tụ, hướng dẫn SymPy nêu các lựa chọn như real_roots hay biểu diễn CRootOf rồi đánh giá số. Việc lựa chọn còn phụ thuộc miền hệ số, yêu cầu chứng nhận và chi phí tính toán; thí nghiệm này không đo tốc độ hoặc đảm bảo một bộ giải luôn tốt hơn bộ giải khác.

Với hệ số từ đo đạc, giữ nhiều chữ số tính toán cũng không làm giảm độ bất định của phép đo. Cần xét cả khoảng sai số đầu vào trước khi diễn giải hai nghiệm rất gần nhau thành hai kết quả có thể phân biệt trong ứng dụng.

Bình luận