第1回:ChatGPTだけで有限要素プログラムは作れるか

ChatGPTで作る有限要素プログラム入門 第1回

Introduction:コードが動くことと,有限要素法が正しいことは同じではない

ChatGPTに「有限要素法のプログラムを書いてください」と頼めば,現在ではかなり長いPythonコードまで生成できます. 弱形式,要素行列,assembly,境界条件,線形方程式の解法,可視化まで,一見すると一通りそろったコードが数秒で現れます.

では,有限要素法を知らなくてもChatGPTだけで有限要素プログラムを作れるのでしょうか. 本連載では,この問いを実際の計算を通して考えます.

本連載の立場
ChatGPTにコードを書かせること自体は難しくない.
難しいのは,そのコードが解くべき離散問題を本当に解いているかを確認することである.

したがって,本連載ではAIが生成したコードを完成品として扱いません. 数式と照合し,数値実験を行い,収束次数を測り,必要ならコードを壊して原因を調べます.

1.最初の問題:1次元Poisson方程式

最初は最も単純な境界値問題から始めます. 区間 \(\Omega=(0,1)\) で \[ -u''(x)=f(x),\qquad 0<x<1, \tag{1} \] \[ u(0)=u(1)=0 \tag{2} \] を考えます.

数値解を検証できるように,厳密解を \[ u(x)=\sin(\pi x) \tag{3} \] と選びます.このとき \[ f(x)=\pi^2\sin(\pi x) \tag{4} \] です.

厳密解が分かっている問題を使うのは,単なる練習のためではありません. AIが作ったプログラムの誤差を直接測れるからです.

2.まずChatGPTに何を頼むか

例えば,最初のpromptを次のようにします.

Prompt
1次元Poisson方程式 \(-u''=f\),\(0<x<1\),\(u(0)=u(1)=0\) を, 一様メッシュ上のP1有限要素法で解くPythonコードを書いてください. 有限要素ライブラリは使わず,NumPyだけで要素行列,assembly,Dirichlet境界条件を実装してください. 厳密解を \(u(x)=\sin(\pi x)\) とし,\(L^2\)相対誤差と \(H^1\)半ノルム相対誤差も計算してください.

このpromptには重要な指定がいくつかあります.

  • P1有限要素:何を離散化するかを固定する.
  • NumPyだけ:有限要素ライブラリの内部処理を隠さない.
  • 要素行列とassembly:有限要素法の核心を明示的に書かせる.
  • 厳密解:生成コードを検証できるようにする.
  • 二種類の相対誤差:単に図がそれらしく見えるだけで終わらせない.

3.コードを書く前に弱形式を確認する

境界条件を満たす試験関数 \(v\in H_0^1(0,1)\) を掛け,部分積分すると \[ \int_0^1 u'(x)v'(x)\,dx = \int_0^1 f(x)v(x)\,dx \tag{5} \] を得ます.

したがって弱形式は, \[ \text{Find }u\in H_0^1(0,1) \text{ such that } a(u,v)=\ell(v) \quad\forall v\in H_0^1(0,1), \tag{6} \] ただし \[ a(u,v):=\int_0^1u'v'\,dx, \qquad \ell(v):=\int_0^1fv\,dx \tag{7} \] です.

最初の数学的監査
生成コードに現れるstiffness matrixは,式 (7) の双線形形式 \(a(\cdot,\cdot)\) を離散化したものでなければならない.

4.P1有限要素では何を近似するのか

節点を \[ 0=x_0<x_1<\cdots<x_N=1, \qquad h=\frac1N \tag{8} \] とします.各要素は \[ T_e=[x_e,x_{e+1}] \tag{9} \] です.

P1有限要素空間を \[ V_h = \{v_h\in C([0,1]):v_h|_{T_e}\in\mathbb P_1(T_e),\ v_h(0)=v_h(1)=0\} \tag{10} \] とします.有限要素近似は \[ a(u_h,v_h)=\ell(v_h) \qquad\forall v_h\in V_h \tag{11} \] を満たす \(u_h\in V_h\) を求める問題です.

ここまでの数式を確認してからコードを見ると,Pythonの各行が何をしているか追跡できます.

5.局所剛性行列は手で計算できる

要素 \(T_e=[x_e,x_{e+1}]\) 上の局所基底を \[ \phi_1(x)=\frac{x_{e+1}-x}{h}, \qquad \phi_2(x)=\frac{x-x_e}{h} \tag{12} \] とすると \[ \phi_1'=-\frac1h, \qquad \phi_2'=\frac1h. \tag{13} \] 従って局所剛性行列は \[ K^{(e)}_{ij} = \int_{T_e}\phi_i'\phi_j'\,dx = \frac1h \begin{pmatrix} 1&-1\\ -1&1 \end{pmatrix}_{ij}. \tag{14} \]

AIが h * [[1,-1],[-1,1]] のような行列を出したら,コードとしては実行できても有限要素法としては間違いです. この \(1/h\) は単なる実装上の係数ではなく,基底関数の微分と積分から出てきます.

6.最小のPythonコード

以下は,本記事で検証する最小構成のコードです. 要素行列,荷重ベクトル,assembly,Dirichlet境界条件,誤差計算をすべて明示しています.

import numpy as np


def solve_fem(N):
    nodes = np.linspace(0.0, 1.0, N + 1)
    A = np.zeros((N + 1, N + 1))
    b = np.zeros(N + 1)

    # 2-point Gauss quadrature on [-1, 1]
    gauss_x = np.array([-1.0 / np.sqrt(3.0),
                         1.0 / np.sqrt(3.0)])
    gauss_w = np.array([1.0, 1.0])

    for e in range(N):
        xL = nodes[e]
        xR = nodes[e + 1]
        h = xR - xL

        Ke = (1.0 / h) * np.array([[ 1.0, -1.0],
                                    [-1.0,  1.0]])
        fe = np.zeros(2)

        for xi, w in zip(gauss_x, gauss_w):
            x = 0.5 * (xL + xR) + 0.5 * h * xi
            phi = np.array([(1.0 - xi) / 2.0,
                            (1.0 + xi) / 2.0])
            f = np.pi**2 * np.sin(np.pi * x)
            fe += w * f * phi * (h / 2.0)

        dofs = [e, e + 1]
        for a in range(2):
            b[dofs[a]] += fe[a]
            for c in range(2):
                A[dofs[a], dofs[c]] += Ke[a, c]

    # homogeneous Dirichlet boundary conditions
    u = np.zeros(N + 1)
    u[1:N] = np.linalg.solve(A[1:N, 1:N], b[1:N])

    return nodes, u


def compute_relative_errors(nodes, uh):
    # 5-point Gauss quadrature for error and exact-solution norms
    gauss_x, gauss_w = np.polynomial.legendre.leggauss(5)

    err_L2_sq = 0.0
    err_H1_sq = 0.0
    norm_L2_sq = 0.0
    norm_H1_sq = 0.0

    for e in range(len(nodes) - 1):
        xL = nodes[e]
        xR = nodes[e + 1]
        h = xR - xL
        ue = uh[e:e + 2]
        duh = (ue[1] - ue[0]) / h

        for xi, w in zip(gauss_x, gauss_w):
            x = 0.5 * (xL + xR) + 0.5 * h * xi
            phi = np.array([(1.0 - xi) / 2.0,
                            (1.0 + xi) / 2.0])

            uh_x = np.dot(ue, phi)
            u_exact = np.sin(np.pi * x)
            du_exact = np.pi * np.cos(np.pi * x)
            jac = h / 2.0

            err_L2_sq += w * (u_exact - uh_x)**2 * jac
            err_H1_sq += w * (du_exact - duh)**2 * jac
            norm_L2_sq += w * u_exact**2 * jac
            norm_H1_sq += w * du_exact**2 * jac

    rel_L2 = np.sqrt(err_L2_sq / norm_L2_sq)
    rel_H1 = np.sqrt(err_H1_sq / norm_H1_sq)
    return rel_L2, rel_H1


for N in [8, 16, 32, 64]:
    nodes, uh = solve_fem(N)
    relL2, relH1 = compute_relative_errors(nodes, uh)
    print(N, relL2, relH1)

7.コードと数式を一行ずつ対応させる

有限要素プログラムを読むときには,Pythonの文法よりも,数式との対応を見ることが重要です.

コード 数学的意味
nodes = np.linspace(...) メッシュ \(\mathcal T_h\) の生成
Ke = (1/h) * ... \(\int_{T_e}\phi_i'\phi_j'\,dx\)
fe += ... \(\int_{T_e}f\phi_i\,dx\)
A[dofs[a], dofs[c]] += ... 局所行列から大域行列へのassembly
u[1:N] = solve(...) \(u_h(0)=u_h(1)=0\) を課した離散問題の解法

この対応が説明できなければ,コードが動いても中身を検証したことにはなりません.

8.最初の数値監査:誤差はどう減るか

滑らかな解に対する1次元P1有限要素法では,標準的な理論から \[ |u-u_h|_{H^1(0,1)}=O(h), \qquad \|u-u_h\|_{L^2(0,1)}=O(h^2) \tag{15} \] が期待されます.

本記事では,絶対誤差ではなく \[ E_{L^2}^{\mathrm{rel}} :=\frac{\|u-u_h\|_{L^2(0,1)}}{\|u\|_{L^2(0,1)}}, \qquad E_{H^1}^{\mathrm{rel}} :=\frac{|u-u_h|_{H^1(0,1)}}{|u|_{H^1(0,1)}} \tag{16} \] を用います.今回の厳密解では \[ \|u\|_{L^2(0,1)}=\frac{1}{\sqrt2}, \qquad |u|_{H^1(0,1)}=\frac{\pi}{\sqrt2}. \] 分母はメッシュ幅に依存しないため,相対誤差でも期待される収束次数はそれぞれ2次と1次です. 上のコードを実行すると,例えば次の値が得られます.

\(N\) \(L^2\) relative error rate \(H^1\) seminorm relative error rate
8 1.4015e-2 — 1.1307e-1 —
16 3.5155e-3 1.995 5.6645e-2 0.997
32 8.7961e-4 1.999 2.8336e-2 0.999
64 2.1995e-4 2.000 1.4170e-2 1.000

理論値と非常によく一致しています. ここで初めて,「少なくともこの問題について,生成された離散化は期待される有限要素近似として振る舞っている」と判断できます.

9.P1要素の基本監査:厳密解が一次式なら誤差は0になる

区分一次有限要素(P1要素)には,実装を確認するための非常に重要な基本テストがあります. 厳密解が一次式なら,有限要素空間がその厳密解をそのまま含むため,理論上の離散化誤差は0になるという性質です. 実際の浮動小数点計算では,線形方程式の解法や四則演算に伴う丸め誤差だけが残ります.

ここで一つ注意があります.前節までの問題は \[ u(0)=u(1)=0 \] という同次Dirichlet境界条件でした.この条件を満たす一次式は \(u\equiv0\) だけなので, 非自明な確認問題として,次の非同次Dirichlet問題を使います: \[ -u''(x)=0,\qquad 0<x<1, \tag{17} \] \[ u(0)=0,\qquad u(1)=1. \tag{18} \] この厳密解は \[ u(x)=x \tag{19} \] です.

9.1 なぜ有限要素誤差が0になるのか

境界値を満たすP1有限要素空間を \[ V_h^g = \{v_h\in C([0,1]):v_h|_T\in\mathbb P_1(T),\ v_h(0)=0,\ v_h(1)=1\} \] とし,試験関数空間を \[ V_h^0 = \{v_h\in C([0,1]):v_h|_T\in\mathbb P_1(T),\ v_h(0)=v_h(1)=0\} \] とします.有限要素解 \(u_h\in V_h^g\) は \[ \int_0^1 u_h'(x)v_h'(x)\,dx=0 \qquad\forall v_h\in V_h^0 \tag{20} \] を満たします.

一方,厳密解 \(u(x)=x\) は全区間で一次式なので,どの要素上でも一次式です.従って \[ u\in V_h^g. \] また \(u'(x)=1\) なので,任意の \(v_h\in V_h^0\) に対して \[ \int_0^1 u'v_h'\,dx = \int_0^1 v_h'(x)\,dx = v_h(1)-v_h(0) = 0. \] 従って厳密解 \(u\) 自身が離散問題 (20) を満たします. Poisson問題の離散解は一意なので, \[ \boxed{u_h=u} \tag{21} \] となります.従って \[ \|u-u_h\|_{L^2(0,1)}=0, \qquad |u-u_h|_{H^1(0,1)}=0. \] 同じ結論は,非同次Dirichlet条件を持ち上げて同次問題に直した上でCéaの補題を適用しても得られます.この場合,厳密解が離散アフィン空間 \(V_h^g\) に含まれるため,最良近似誤差は0です.

P1要素のlinear patch test
厳密解が一次式で,境界条件・要素積分・assemblyが正しく実装されているなら, P1有限要素解は厳密解をそのまま再現する.
したがって,観測される誤差は理論上0であり,数値計算では機械精度程度の丸め誤差だけが残る.

9.2 Pythonで確認する

同じstiffness matrixを使い,非同次Dirichlet境界条件 \(u(0)=0\),\(u(1)=1\) を正しく消去して計算します.

def solve_linear_patch_test(N):
    nodes = np.linspace(0.0, 1.0, N + 1)
    A = np.zeros((N + 1, N + 1))
    b = np.zeros(N + 1)

    for e in range(N):
        xL = nodes[e]
        xR = nodes[e + 1]
        h = xR - xL

        Ke = (1.0 / h) * np.array([[ 1.0, -1.0],
                                    [-1.0,  1.0]])

        dofs = [e, e + 1]
        for a in range(2):
            for c in range(2):
                A[dofs[a], dofs[c]] += Ke[a, c]

    # u(0)=0, u(1)=1
    uh = np.zeros(N + 1)
    uh[0] = 0.0
    uh[N] = 1.0

    interior = np.arange(1, N)
    boundary = np.array([0, N])

    rhs = b[interior] - A[np.ix_(interior, boundary)] @ uh[boundary]
    uh[interior] = np.linalg.solve(
        A[np.ix_(interior, interior)], rhs
    )

    return nodes, uh


def linear_patch_relative_errors(nodes, uh):
    gauss_x, gauss_w = np.polynomial.legendre.leggauss(5)

    err_L2_sq = 0.0
    err_H1_sq = 0.0
    norm_L2_sq = 0.0
    norm_H1_sq = 0.0

    for e in range(len(nodes) - 1):
        xL = nodes[e]
        xR = nodes[e + 1]
        h = xR - xL
        ue = uh[e:e + 2]
        duh = (ue[1] - ue[0]) / h

        for xi, w in zip(gauss_x, gauss_w):
            x = 0.5 * (xL + xR) + 0.5 * h * xi
            phi = np.array([(1.0 - xi) / 2.0,
                            (1.0 + xi) / 2.0])

            uh_x = np.dot(ue, phi)
            u_exact = x
            du_exact = 1.0
            jac = h / 2.0

            err_L2_sq += w * (u_exact - uh_x)**2 * jac
            err_H1_sq += w * (du_exact - duh)**2 * jac
            norm_L2_sq += w * u_exact**2 * jac
            norm_H1_sq += w * du_exact**2 * jac

    rel_L2 = np.sqrt(err_L2_sq / norm_L2_sq)
    rel_H1 = np.sqrt(err_H1_sq / norm_H1_sq)
    max_nodal = np.max(np.abs(uh - nodes))

    return rel_L2, rel_H1, max_nodal


for N in [4, 8, 16, 32]:
    nodes, uh = solve_linear_patch_test(N)
    relL2, relH1, nodal = linear_patch_relative_errors(nodes, uh)
    print(N, relL2, relH1, nodal)

9.3 数値結果

実際に計算すると,誤差は \(10^{-16}\) から \(10^{-15}\) 程度で,有限要素離散化誤差ではなく浮動小数点演算の丸め誤差の水準にあります.

\(N\) \(L^2\) relative error \(H^1\) seminorm relative error max nodal error
4 1.5482e-16 2.6037e-16 1.1102e-16
8 1.1678e-16 3.6822e-16 1.1102e-16
16 7.0759e-17 2.6037e-16 5.5511e-17
32 2.6030e-15 5.3621e-15 2.3315e-15

\(N\) を増やしても誤差が一定の収束次数で減るわけではありません. そもそも離散化誤差が0だからです.残っているのは丸め誤差なので,線形方程式のサイズや計算順序によって多少増減します. このテストで \(10^{-3}\) や \(10^{-6}\) 程度の系統的な誤差が出るなら, 境界条件,assembly,要素行列,あるいは誤差計算のどこかを疑うべきです.

この一次式再現性は,今後2次元三角形P1要素を実装するときにもそのまま使えます. 2次元では \(u(x,y)=a+bx+cy\) を厳密解に選び,三角形メッシュ上で同じlinear patch testを行うことができます.

10.なぜ図を見るだけでは足りないのか

有限要素解と厳密解を同じ図に描くと,\(N=20\) 程度でもほとんど重なって見えます. しかし,それだけでは次の誤りを見逃す可能性があります.

  • 局所行列のscaleが間違っている.
  • Jacobianの係数を一つ落としている.
  • 荷重積分のquadratureが不十分である.
  • 境界自由度を誤って処理している.
  • assemblyのlocal-to-global numberingがずれている.
  • 誤差計算そのものが間違っている.

解の形が「それらしい」ことは,正しい有限要素近似であることの証明ではありません. 収束次数は非常に強力なdebugging toolです.

11.ChatGPTはどこで間違えやすいか

今回のような1次元P1問題は単純ですが,次元や要素が変わると確認項目は急速に増えます. 特に注意したいのは次です.

  1. reference elementとphysical elementの変換:Jacobian,\(J^{-1}\),\(J^{-\top}\) の使い分け.
  2. 積分measure:変数変換に伴う \(|\det J|\).
  3. vector element:Raviart–ThomasやNédélec要素でのPiola変換.
  4. nonconforming method:自由度の連続性とconsistency term.
  5. anisotropic mesh:通常のshape-regular scalingを無意識に使っていないか.

つまり,AIが便利になるほど,数値解析の知識が不要になるというより, 何を監査すべきかを知ることの価値が上がると考えた方がよいでしょう.

12.「ChatGPTだけで作れるか」への第1回の答え

今回のような小さな問題なら,ChatGPTとの対話だけで,動作する有限要素コードをかなり短時間で作れます. しかし,「作れた」という言葉には少なくとも三段階あります.

三つの段階

1.Pythonコードが実行できる.
2.意図した離散有限要素問題を実装している.
3.その離散解が元の偏微分方程式の解へ期待された次数で収束する.

ChatGPTが主に助けてくれるのは1と2の間です. 2から3を確認するには,弱形式,有限要素空間,補間誤差,安定性,数値誤差の考え方が必要になります.

従って,第1回の答えは次のようになります.

ChatGPTだけでも有限要素プログラムの形は作れる.
しかし,それが有限要素法として正しいことを確認するには,数学的監査が必要である.

13.この連載でどこまで進むか

今後は,単なるコード生成から少しずつ有限要素法の本体へ進みます.

  1. 1次元Poisson問題を弱形式から組み立てる.
  2. 要素行列とassemblyを詳しく読む.
  3. 2次元三角形P1要素を実装する.
  4. Jacobianとreference elementを監査する.
  5. \(L^2\)・\(H^1\)相対誤差と収束次数を自動計算する.
  6. 非一様mesh・細長い三角形を入れてみる.
  7. Crouzeix–Raviart要素へ進む.
  8. Raviart–Thomas要素とPiola変換を実装する.
  9. Stokes・Nitsche・DG型手法へ進む.

特にメッシュの幾何が計算へ与える影響については,既存の 「異方性有限要素法の幾何学的基礎」第1回 とも接続していきます.

参考文献

ページの先頭へ