0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

@mrrclb48z

「ベクトル解析の基本恒等式を教えて下さい。」をsympyでAI先生に教えてもらいました。

0
Last updated at Posted at 2026-06-27

(本日の)ChatGPT先生へ

ベクトル解析の基本恒等式を教えて下さい。

(表示を省略)

  1. grad の curl は 0...rot(gradf)=∇×(∇f)=0
  2. curl の div は 0...div(rotA)=∇⋅(∇×A)=0
  3. curl の curl...rot(rotA)=grad(divA)−∇2A,∇×(∇×A)=∇(∇⋅A)−∇2A,
  4. div(fA)...div(fA)=fdivA+(gradf)⋅A
  5. grad(fg)...grad(fg)=fgradg+ggradf
  6. rot(fA)...rot(fA)=(gradf)×A+frotA
  7. div(A×B)...div(A×B)=B⋅(rotA)−A⋅(rotB)
  8. rot(A×B)...rot(A×B)=A(divB)−B(divA)+(B⋅∇)A−(A⋅∇)B
  9. grad(A·B)...∇(A⋅B)=(A⋅∇)B+(B⋅∇)A+A×(∇×B)+B×(∇×A)
  10. ラプラシアン...△A=grad(divA)-rot(rotA)
説明してください SymPy での確認方法

1. grad の curl は 0　sysmpyで

from sympy import symbols
from sympy.vector import CoordSys3D, gradient, curl

# 座標系
N = CoordSys3D('N')

# 座標
x, y, z = N.x, N.y, N.z

# 任意のスカラー場
f = x**2*y + y*z + x*z**2

print("f =")
print(f)

# grad f
grad_f = gradient(f)

print("\ngrad(f) =")
print(grad_f)

# curl(grad(f))
rot_grad = curl(grad_f)

print("\nrot(grad(f)) =")
print(rot_grad)

実行結果

f =
N.x**2*N.y + N.x*N.z**2 + N.y*N.z

grad(f) =
(2*N.x*N.y + N.z**2)*N.i + (N.x**2 + N.z)*N.j + (2*N.x*N.z + N.y)*N.k

rot(grad(f)) =
0

より一般的な例

from sympy import Function
from sympy.vector import CoordSys3D, gradient, curl

N = CoordSys3D('N')

x, y, z = N.x, N.y, N.z

f = Function('f')(x, y, z)

print(curl(gradient(f)))

実行結果

0

2. curl の div は 0　sympy で

from sympy import Function
from sympy.vector import CoordSys3D, divergence, curl

# 座標系
R = CoordSys3D('R')

# 座標
x, y, z = R.x, R.y, R.z

# 任意のベクトル場
A = (Function('A1')(x, y, z) * R.i +
     Function('A2')(x, y, z) * R.j +
     Function('A3')(x, y, z) * R.k)

print("A =")
print(A)

# curl(A)
rot_A = curl(A)

print("\ncurl(A) =")
print(rot_A)

# div(curl(A))
div_rot_A = divergence(rot_A)

print("\ndiv(curl(A)) =")
print(div_rot_A)

実行結果

A =
A1(R.x, R.y, R.z)*R.i
+ A2(R.x, R.y, R.z)*R.j
+ A3(R.x, R.y, R.z)*R.k

curl(A) =
・・・

div(curl(A)) =
0

3. curl の curl　sympy で

方法1（sympy.vector を使用）

from sympy import symbols, simplify
from sympy.vector import CoordSys3D, gradient, divergence, curl

# 座標系
R = CoordSys3D('R')

x, y, z = R.base_scalars()

# ベクトル場
A = (x**2*y + z)*R.i \
  + (x*z + y**2)*R.j \
  + (x*y + z**2)*R.k

# 左辺
lhs = curl(curl(A))

# 右辺
rhs = gradient(divergence(A)) - (
    A.dot(R.i).laplacian()*R.i +
    A.dot(R.j).laplacian()*R.j +
    A.dot(R.k).laplacian()*R.k
)

print("curl(curl(A))")
print(lhs)

print()

print("grad(div(A)) - Laplacian(A)")
print(rhs)

print()

print("Difference")
print(simplify(lhs-rhs))

実行結果

Difference
0

方法2（成分表示）

from sympy import *
from sympy.vector import CoordSys3D, curl, gradient, divergence

R = CoordSys3D('R')

x, y, z = R.base_scalars()

P = x**2*y + z
Q = x*z + y**2
Rz = x*y + z**2

A = P*R.i + Q*R.j + Rz*R.k

# curl(curl(A))
C = curl(curl(A))
print(expand(C))

出力

(-1)*R.i + (-1)*R.j + 0*R.k

# grad(div(A))
G = gradient(divergence(A))
print(expand(G))

# ベクトルラプラシアン
L = P.laplacian()*R.i + \
    Q.laplacian()*R.j + \
    Rz.laplacian()*R.k

print(expand(L))

print(expand(G - L))

(-1)*R.i + (-1)*R.j + 0*R.k

4. div(fA)　sympy で

from sympy import symbols, simplify
from sympy.vector import CoordSys3D, gradient, divergence

# 座標系
R = CoordSys3D('R')

# 座標
x, y, z = R.x, R.y, R.z

# スカラー場
f = x*y*z

# ベクトル場
A = (x**2)*R.i + (y**2)*R.j + (z**2)*R.k

# 左辺 div(fA)
lhs = divergence(f*A)

# 右辺 f div(A) + grad(f)・A
rhs = f*divergence(A) + gradient(f).dot(A)

print("LHS =", lhs)
print("RHS =", rhs)
print("LHS - RHS =", simplify(lhs-rhs))

実行結果

LHS = 5*x**2*y*z + 5*x*y**2*z + 5*x*y*z**2
RHS = 5*x**2*y*z + 5*x*y**2*z + 5*x*y*z**2
LHS - RHS = 0

from sympy import pprint
from sympy.vector import CoordSys3D, gradient, divergence

R = CoordSys3D('R')
x, y, z = R.x, R.y, R.z

f = x*y*z
A = x**2*R.i + y**2*R.j + z**2*R.k

print("div(fA)")
pprint(divergence(f*A))

print("\nf div(A)")
pprint(f*divergence(A))

print("\ngrad(f)・A")
pprint(gradient(f).dot(A))

5. grad(fg)　sympy で

from sympy import symbols, simplify
from sympy.vector import CoordSys3D, gradient

# 座標系
R = CoordSys3D('R')

# 座標
x, y, z = R.x, R.y, R.z

# スカラー場
f = x**2 + y*z
g = x*y + z**2

# 左辺 grad(fg)
lhs = gradient(f * g)

# 右辺 f grad(g) + g grad(f)
rhs = f * gradient(g) + g * gradient(f)

print("grad(fg) =")
print(lhs)

print("\nf grad(g) + g grad(f) =")
print(rhs)

print("\n差 =")
print(simplify(lhs - rhs))

実行結果

grad(fg) =
(・・・)

f grad(g) + g grad(f) =
(・・・)

差 =
0

from sympy import symbols, simplify
from sympy.vector import CoordSys3D, gradient

R = CoordSys3D('R')

x, y, z = R.x, R.y, R.z

f = x**2 + y*z
g = x*y + z**2

lhs = gradient(f*g)
rhs = f*gradient(g) + g*gradient(f)

print(simplify(lhs.dot(R.i) - rhs.dot(R.i)))
print(simplify(lhs.dot(R.j) - rhs.dot(R.j)))
print(simplify(lhs.dot(R.k) - rhs.dot(R.k)))

0
0
0

6. rot(fA)　sympy で

from sympy import symbols, simplify
from sympy.vector import CoordSys3D, gradient, curl

# 座標系
R = CoordSys3D('R')

# 座標
x, y, z = R.base_scalars()

# スカラー場
f = x*y*z

# ベクトル場
A = (x**2)*R.i + (y*z)*R.j + (x+y)*R.k

# 左辺
lhs = curl(f*A)

# 右辺
rhs = gradient(f).cross(A) + f*curl(A)

print("curl(f*A) =")
print(lhs)

print("\ngrad(f) × A + f curl(A) =")
print(rhs)

print("\nDifference =")
print(simplify(lhs-rhs))

実行結果

curl(f*A) =
(... ベクトル式 ...)

grad(f) × A + f curl(A) =
(... 同じベクトル式 ...)

Difference =
0

diff = lhs - rhs

print(simplify(diff.dot(R.i)))
print(simplify(diff.dot(R.j)))
print(simplify(diff.dot(R.k)))

0
0
0

7. div(A×B) sympyで

from sympy import symbols, simplify
from sympy.vector import CoordSys3D, divergence, curl

# 座標系
N = CoordSys3D('N')

x, y, z = N.base_scalars()

# ベクトル場 A
A = (x*y)*N.i + (y*z)*N.j + (z*x)*N.k

# ベクトル場 B
B = (x**2)*N.i + (y**2)*N.j + (z**2)*N.k

# 左辺
lhs = divergence(A.cross(B))

# 右辺
rhs = B.dot(curl(A)) - A.dot(curl(B))

print("lhs =", lhs)
print("rhs =", rhs)
print("lhs-rhs =", simplify(lhs-rhs))

実行結果

lhs = x**2*z - x*y**2 + y*z**2
rhs = x**2*z - x*y**2 + y*z**2
lhs-rhs = 0

from sympy import Function, symbols, simplify
from sympy.vector import CoordSys3D, divergence, curl

N = CoordSys3D('N')
x, y, z = N.base_scalars()

Ax = Function('Ax')(x, y, z)
Ay = Function('Ay')(x, y, z)
Az = Function('Az')(x, y, z)

Bx = Function('Bx')(x, y, z)
By = Function('By')(x, y, z)
Bz = Function('Bz')(x, y, z)

A = Ax*N.i + Ay*N.j + Az*N.k
B = Bx*N.i + By*N.j + Bz*N.k

lhs = divergence(A.cross(B))
rhs = B.dot(curl(A)) - A.dot(curl(B))

print(simplify(lhs-rhs))

実行結果

0

8. rot(A×B)　sympy で

from sympy import symbols, simplify
from sympy.vector import CoordSys3D, gradient, divergence, curl

# 座標系
R = CoordSys3D('R')

x, y, z = R.x, R.y, R.z

# 任意のベクトル場
A = x*y*R.i + y*z*R.j + z*x*R.k
B = (x+y)*R.i + (y+z)*R.j + (z+x)*R.k

# 左辺
lhs = curl(A.cross(B))

# (B・∇)A
BA = (
    B.dot(gradient(A.dot(R.i))) * R.i +
    B.dot(gradient(A.dot(R.j))) * R.j +
    B.dot(gradient(A.dot(R.k))) * R.k
)

# (A・∇)B
AB = (
    A.dot(gradient(B.dot(R.i))) * R.i +
    A.dot(gradient(B.dot(R.j))) * R.j +
    A.dot(gradient(B.dot(R.k))) * R.k
)

# 右辺
rhs = (
    A * divergence(B)
    - B * divergence(A)
    + BA
    - AB
)

print("lhs =", lhs)
print("rhs =", rhs)

print("\nDifference")
print(simplify(lhs - rhs))

Difference
0

from sympy import Function
from sympy.vector import CoordSys3D

R = CoordSys3D('R')
x, y, z = R.x, R.y, R.z

Ax = Function('Ax')(x, y, z)
Ay = Function('Ay')(x, y, z)
Az = Function('Az')(x, y, z)

Bx = Function('Bx')(x, y, z)
By = Function('By')(x, y, z)
Bz = Function('Bz')(x, y, z)

A = Ax*R.i + Ay*R.j + Az*R.k
B = Bx*R.i + By*R.j + Bz*R.k

9. grad(A·B)　sympy で

from sympy import simplify
from sympy.vector import CoordSys3D, gradient, curl

# 座標系
R = CoordSys3D('R')
x, y, z = R.x, R.y, R.z

# ベクトル場 A
A = (
    x*y * R.i
  + y*z * R.j
  + z*x * R.k
)

# ベクトル場 B
B = (
    x**2 * R.i
  + y**2 * R.j
  + z**2 * R.k
)

#-------------------------------
# 左辺 grad(A・B)
#-------------------------------
lhs = gradient(A.dot(B))

#-------------------------------
# (A・∇)B
#-------------------------------
BA = (
    (A.dot(R.i)*B.dot(R.i).diff(x)
   + A.dot(R.j)*B.dot(R.i).diff(y)
   + A.dot(R.k)*B.dot(R.i).diff(z))*R.i

  + (A.dot(R.i)*B.dot(R.j).diff(x)
   + A.dot(R.j)*B.dot(R.j).diff(y)
   + A.dot(R.k)*B.dot(R.j).diff(z))*R.j

  + (A.dot(R.i)*B.dot(R.k).diff(x)
   + A.dot(R.j)*B.dot(R.k).diff(y)
   + A.dot(R.k)*B.dot(R.k).diff(z))*R.k
)

#-------------------------------
# (B・∇)A
#-------------------------------
AB = (
    (B.dot(R.i)*A.dot(R.i).diff(x)
   + B.dot(R.j)*A.dot(R.i).diff(y)
   + B.dot(R.k)*A.dot(R.i).diff(z))*R.i

  + (B.dot(R.i)*A.dot(R.j).diff(x)
   + B.dot(R.j)*A.dot(R.j).diff(y)
   + B.dot(R.k)*A.dot(R.j).diff(z))*R.j

  + (B.dot(R.i)*A.dot(R.k).diff(x)
   + B.dot(R.j)*A.dot(R.k).diff(y)
   + B.dot(R.k)*A.dot(R.k).diff(z))*R.k
)

#-------------------------------
# A×curl(B)
#-------------------------------
term3 = A.cross(curl(B))

#-------------------------------
# B×curl(A)
#-------------------------------
term4 = B.cross(curl(A))

rhs = AB + BA + term3 + term4

print("LHS =", lhs)
print()
print("RHS =", rhs)
print()

print("Difference")
print(simplify(lhs.to_matrix(R) - rhs.to_matrix(R)))

実行結果

Matrix([
[0],
[0],
[0]])

10. ラプラシアン　sympy で

from sympy import symbols, Function
from sympy.vector import CoordSys3D, gradient, divergence, curl

# 座標系
R = CoordSys3D('R')
x, y, z = R.x, R.y, R.z

# ベクトル場
Ax = Function('A_x')(x, y, z)
Ay = Function('A_y')(x, y, z)
Az = Function('A_z')(x, y, z)

A = Ax*R.i + Ay*R.j + Az*R.k

# ベクトルラプラシアン
lapA = gradient(divergence(A)) - curl(curl(A))

print("ΔA =")
print(lapA)

from sympy import symbols, Function, diff
from sympy.vector import CoordSys3D

R = CoordSys3D('R')
x, y, z = R.x, R.y, R.z

Ax = Function('A_x')(x, y, z)
Ay = Function('A_y')(x, y, z)
Az = Function('A_z')(x, y, z)

def lap(f):
    return diff(f, x, 2) + diff(f, y, 2) + diff(f, z, 2)

DeltaA = (
    lap(Ax)*R.i +
    lap(Ay)*R.j +
    lap(Az)*R.k
)

print(DeltaA)

lhs = (
    lap(Ax)*R.i +
    lap(Ay)*R.j +
    lap(Az)*R.k
)

rhs = gradient(divergence(A)) - curl(curl(A))

print(lhs - rhs)

0

いつもと違うおすすめです。

Qiita内

0
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
Sign upLogin
0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?