10.1 複數、高斯平面與兩維微積分（1831 年）#

import sympy as sp

z = sp.Symbol('z')
w = 3 + 4 * sp.I

print("w =", w)
print("Re(w) =", sp.re(w), " Im(w) =", sp.im(w))
print("|w| =", sp.Abs(w), " arg(w) =", sp.arg(w))
print("conjugate(w) =", sp.conjugate(w))
print("w * conjugate(w) =", sp.expand(w * sp.conjugate(w)))
print("1/w =", sp.simplify(1 / w))
print("expand_complex(1/w) =", sp.expand_complex(1 / w))
print()
# modulus identity |z1 z2| = |z1||z2|
z1, z2 = sp.symbols('z1 z2')
print("|z1 z2| - |z1||z2| =", sp.simplify(sp.Abs(z1 * z2) - sp.Abs(z1) * sp.Abs(z2)))

w = 3 + 4*I
Re(w) = 3  Im(w) = 4
|w| = 5  arg(w) = atan(4/3)
conjugate(w) = 3 - 4*I
w * conjugate(w) = 25
1/w = 3/25 - 4*I/25
expand_complex(1/w) = 3/25 - 4*I/25

|z1 z2| - |z1||z2| = 0

import cmath
import numpy as np
import sympy as sp

t = sp.Symbol('t', real=True)

print("=== 1. 歐拉公式 e^{iθ} = cos θ + i sin θ ===")
lhs = sp.exp(sp.I * t)
rhs = sp.cos(t) + sp.I * sp.sin(t)
print("  exp(i*t) - (cos t + i sin t) =", sp.simplify(sp.expand_complex(lhs - rhs)))
print()

print("=== 2. 極形式 z = r e^{iθ} ===")
z0 = 1 + sp.sqrt(3) * sp.I
r = sp.Abs(z0)
theta = sp.arg(z0)
print("  z =", z0)
print("  r = |z| =", r, " ; θ = arg(z) =", theta, " ； 等於 π/3？", sp.simplify(theta - sp.pi / 3) == 0)
back = sp.simplify(sp.expand_complex(r * sp.exp(sp.I * theta)))
print("  r e^{iθ} =", back, " ； 與原來的 z 相同？", sp.simplify(back - z0) == 0)
print()

print("=== 3. De Moivre 公式：(cos θ + i sin θ)^n = cos nθ + i sin nθ ===")
n = 7
lhs2 = sp.expand_complex((sp.cos(theta) + sp.I * sp.sin(theta)) ** n)
rhs2 = sp.expand_complex(sp.cos(n * theta) + sp.I * sp.sin(n * theta))
print("  (cos θ + i sin θ)^7 - (cos 7θ + i sin 7θ) =", sp.simplify(lhs2 - rhs2))
print("  （注意 sin θ 與 cos θ 中 θ = π/3 代入後自動化簡）")
print()

print("=== 4. 乘法的幾何意義：模相乘、角相加 ===")
z1, z2 = sp.symbols('z1 z2')
print("  |z1 z2| - |z1||z2| =", sp.simplify(sp.Abs(z1 * z2) - sp.Abs(z1) * sp.Abs(z2)))
print("  數值檢查 arg(z1 z2) - arg z1 - arg z2 （應為 2π 的整數倍）：")
for u, v in [(1 + 1j, 1 - 1j), (-1 + 0j, 1 + 1j), (2 + 3j, -1 + 1j)]:
    d = cmath.phase(u * v) - cmath.phase(u) - cmath.phase(v)
    print("      u=%-6s v=%-6s 相位差 = %+.6f = %+.6f * pi" % (u, v, d, d / np.pi))
print()

=== 1. 歐拉公式 e^{iθ} = cos θ + i sin θ ===
  exp(i*t) - (cos t + i sin t) = 0

=== 2. 極形式 z = r e^{iθ} ===
  z = 1 + sqrt(3)*I
  r = |z| = 2  ; θ = arg(z) = pi/3  ； 等於 π/3？ True
  r e^{iθ} = 1 + sqrt(3)*I  ； 與原來的 z 相同？ True

=== 3. De Moivre 公式：(cos θ + i sin θ)^n = cos nθ + i sin nθ ===
  (cos θ + i sin θ)^7 - (cos 7θ + i sin 7θ) = 0
  （注意 sin θ 與 cos θ 中 θ = π/3 代入後自動化簡）

=== 4. 乘法的幾何意義：模相乘、角相加 ===
  |z1 z2| - |z1||z2| = 0
  數值檢查 arg(z1 z2) - arg z1 - arg z2 （應為 2π 的整數倍）：
      u=(1+1j) v=(1-1j) 相位差 = +0.000000 = +0.000000 * pi
      u=(-1+0j) v=(1+1j) 相位差 = -6.283185 = -2.000000 * pi
      u=(2+3j) v=(-1+1j) 相位差 = -6.283185 = -2.000000 * pi

import sympy as sp

x, y = sp.symbols('x y', real=True)
z = x + sp.I * y

u = sp.Function('u')(x, y)
v = sp.Function('v')(x, y)

# CR 方程 in u,v form
cr1 = sp.diff(u, x) - sp.diff(v, y)
cr2 = sp.diff(u, y) + sp.diff(v, x)
print("CR (u,v):  u_x = v_y ?  殘差 =", cr1, " ;  u_y = -v_x ?  殘差 =", cr2)
print()

# check concrete holomorphic functions
funcs = {
    "z**3": z**3,
    "exp(z)": sp.exp(z),
    "sin(z)": sp.sin(z),
    "log(z)": sp.log(z),
    "1/z": 1 / z,
}
for name, f in funcs.items():
    f = sp.simplify(f)
    uu = sp.re(sp.expand_complex(f))
    vv = sp.im(sp.expand_complex(f))
    r1 = sp.simplify(sp.diff(uu, x) - sp.diff(vv, y))
    r2 = sp.simplify(sp.diff(uu, y) + sp.diff(vv, x))
    print(f"{name:>8}: u_x - v_y = {r1},  u_y + v_x = {r2}")
print()

# non-holomorphic example: f(z) = conj(z)
f = sp.conjugate(z)
uu = sp.re(sp.expand_complex(f))
vv = sp.im(sp.expand_complex(f))
print("f(z) = conj(z): u =", uu, " v =", vv)
print("  u_x - v_y =", sp.simplify(sp.diff(uu, x) - sp.diff(vv, y)))
print("  u_y + v_x =", sp.simplify(sp.diff(uu, y) + sp.diff(vv, x)))
print()

# polar form of CR: u_r = (1/r) v_theta , v_r = -(1/r) u_theta
r, th = sp.symbols('r theta', positive=True, real=True)
U = sp.Function('U')(r, th)
V = sp.Function('V')(r, th)
print("polar CR:  r*U_r - V_theta =", sp.simplify(r * sp.diff(U, r) - sp.diff(V, th)))
print("polar CR:  r*V_r + U_theta =", sp.simplify(r * sp.diff(V, r) + sp.diff(U, th)))
print()

# polar CR checked on f(z) = z**2
f = (r * sp.exp(sp.I * th)) ** 2
uu = sp.re(sp.expand_complex(f))
vv = sp.im(sp.expand_complex(f))
print("z^2 polar: u =", sp.simplify(uu), " v =", sp.simplify(vv))
print("  r*u_r - v_theta =", sp.simplify(r * sp.diff(uu, r) - sp.diff(vv, th)))
print("  r*v_r + u_theta =", sp.simplify(r * sp.diff(vv, r) + sp.diff(uu, th)))

CR (u,v):  u_x = v_y ?  殘差 = Derivative(u(x, y), x) - Derivative(v(x, y), y)  ;  u_y = -v_x ?  殘差 = Derivative(u(x, y), y) + Derivative(v(x, y), x)

    z**3: u_x - v_y = 0,  u_y + v_x = 0
  exp(z): u_x - v_y = 0,  u_y + v_x = 0
  sin(z): u_x - v_y = 0,  u_y + v_x = 0
  log(z): u_x - v_y = 0,  u_y + v_x = 0
     1/z: u_x - v_y = 0,  u_y + v_x = 0

f(z) = conj(z): u = x  v = -y
  u_x - v_y = 2
  u_y + v_x = 0

polar CR:  r*U_r - V_theta = r*Derivative(U(r, theta), r) - Derivative(V(r, theta), theta)
polar CR:  r*V_r + U_theta = r*Derivative(V(r, theta), r) + Derivative(U(r, theta), theta)

z^2 polar: u = r**2*cos(2*theta)  v = r**2*sin(2*theta)
  r*u_r - v_theta = 0
  r*v_r + u_theta = 0

import sympy as sp

z = sp.Symbol('z')
h = sp.Symbol('h', complex=True)
t = sp.Symbol('t', real=True)
phi = sp.Symbol('phi', real=True)

def directional_derivative(f, z0, direction):
    """沿 direction 方向計算差商極限；direction 為 'real' / 'imag' / 一般 phi"""
    num = f.subs(z, z0 + h) - f.subs(z, z0)
    if direction == 'real':
        return sp.limit(sp.simplify(num / h), h, 0)
    if direction == 'imag':
        return sp.limit(sp.simplify((num / h).subs(h, sp.I * t)), t, 0)
    d = sp.exp(sp.I * phi) * t
    return sp.simplify(sp.limit(sp.expand((num / h).subs(h, d)), t, 0))

cases = [
    ("z",            z),
    ("z**2",         z**2),
    ("conj(z)",      sp.conjugate(z)),
    ("z*conj(z)",    z * sp.conjugate(z)),
    ("Abs(z)",       sp.Abs(z)),
]

print(f"{'f(z)':>12} {'實方向 h':>16} {'虛方向 h=i*t':>18} {'方向 phi':>18}")
print("-" * 70)
for name, f in cases:
    dr = directional_derivative(f, 0, 'real')
    di = directional_derivative(f, 0, 'imag')
    dp = directional_derivative(f, 0, 'phi')
    print(f"{name:>12} {str(dr):>16} {str(di):>18} {str(dp):>18}")
print()
print("判讀：若三個方向的極限一致，則 f 在 0 處複可導；否則不可導。")
print("  z*conj(z) 三者皆為 0 -> 在 0 處複可導，但導數不連續（故非全純）")
print("  Abs(z) 三者不一致  -> 在 0 處不可導")
print()

        f(z)            實方向 h          虛方向 h=i*t             方向 phi
----------------------------------------------------------------------
           z                1                  1                  1
        z**2                0                  0                  0
     conj(z)                1                 -1      exp(-2*I*phi)
   z*conj(z)                0                  0                  0
      Abs(z)                1                 -I        exp(-I*phi)

判讀：若三個方向的極限一致，則 f 在 0 處複可導；否則不可導。
  z*conj(z) 三者皆為 0 -> 在 0 處複可導，但導數不連續（故非全純）
  Abs(z) 三者不一致  -> 在 0 處不可導

import numpy as np
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 3, figsize=(15, 5))
th = np.linspace(0, 2 * np.pi, 400)

def draw(ax, wfunc, title, radii, nray=8):
    for r in radii:
        z = r * np.exp(1j * th)
        w = wfunc(z)
        ax.plot(w.real, w.imag, lw=1.6)
    for a in np.linspace(0, 2 * np.pi, nray)[:-1]:
        rr = np.linspace(0.02, 3.0, 300)
        z = rr * np.exp(1j * a)
        w = wfunc(z)
        ax.plot(w.real, w.imag, lw=1.0, ls='--', alpha=0.7)
    ax.set_title(title)
    ax.set_xlabel("Re w")
    ax.set_ylabel("Im w")
    ax.set_aspect('equal')
    ax.grid(alpha=0.3)

draw(axes[0], lambda z: z**2, r"$z \mapsto z^2$", [0.5, 1.0, 1.5, 2.0])
draw(axes[1], lambda z: 1 / z, r"$z \mapsto 1/z$", [0.5, 1.0, 2.0])
draw(axes[2], lambda z: z + 1 / z, r"$z \mapsto z + 1/z$ (Joukowski)", [0.5, 1.0, 2.0])

plt.tight_layout()
plt.savefig("/tmp/ch10_mapping.png", dpi=120)
print("saved /tmp/ch10_mapping.png")

# --- 數值檢查 1：z^2 把 |z|=r 映到 |w|=r^2，arg 加倍 ---
r = 1.5
th0 = 0.4
z = r * np.exp(1j * th0)
w = z**2
print("z =", z)
print("  |z| =", abs(z), " |z^2| =", abs(w), " (r^2 =", r**2, ")")
print("  arg(z) =", np.angle(z), " arg(z^2) =", np.angle(w), " (2*arg(z) =", 2 * np.angle(z), ")")
print()

# --- 數值檢查 2：1/z 把直線 Re z = c 映成圓 (圓心 1/(2c), 半徑 1/(2c)) ---
c = 1.5
tt = np.linspace(-1e4, 1e4, 200001)
z = c + 1j * tt
w = 1 / z
center = 1 / (2 * c)
radius = np.abs(w - center)
print("直線 Re z =", c, " 的像：")
print("  理論圓心 =", center, " 理論半徑 =", 1 / (2 * c))
print("  實測 |w - 圓心| 的最大/最小 =", radius.max(), "/", radius.min())
print()

# --- 數值檢查 3：|z|=r 在 1/z 下映到 |w|=1/r ---
r = 2.0
z = r * np.exp(1j * th)
w = 1 / z
print("圓 |z| =", r, " 的像：|w| 恆為", np.abs(w).min(), "~", np.abs(w).max(), " (理論 1/r =", 1 / r, ")")

saved /tmp/ch10_mapping.png
z = (1.3815914910043277+0.5841275134629758j)
  |z| = 1.5  |z^2| = 2.25  (r^2 = 2.25 )
  arg(z) = 0.4  arg(z^2) = 0.8  (2*arg(z) = 0.8 )

直線 Re z = 1.5  的像：
  理論圓心 = 0.3333333333333333  理論半徑 = 0.3333333333333333
  實測 |w - 圓心| 的最大/最小 = 0.3333333333333334 / 0.33333333333333326

圓 |z| = 2.0  的像：|w| 恆為 0.4999999999999999 ~ 0.5000000000000001  (理論 1/r = 0.5 )

import sympy as sp
import numpy as np

x, y = sp.symbols('x y', real=True)
zc = sp.Symbol('z')
z = x + sp.I * y

# ---------- 1. 調和性：全純函數的實部必為調和函數 ----------
print("=== 1. 調和性 (Laplace 方程) ===")
for name, f in [("z**3", zc**3), ("exp(z)", sp.exp(zc)), ("1/z", 1 / zc), ("log(z)", sp.log(zc))]:
    u = sp.re(sp.expand_complex(f.subs(zc, z)))
    lap = sp.simplify(sp.diff(u, x, 2) + sp.diff(u, y, 2))
    print("  u = Re(%-8s) = %-22s ;  u_xx + u_yy = %s" % (name, sp.simplify(u), lap))
print("  對照：u = |z|^2 (非全純) 的 Laplace =",
      sp.simplify(sp.diff(x**2 + y**2, x, 2) + sp.diff(x**2 + y**2, y, 2)))
print()

# ---------- 2. 調和共軛：實部唯一決定虛部（差一個常數）----------
print("=== 2. 調和共軛：u 決定 v ===")
u = x**3 - 3 * x * y**2
print("  u =", u)
v = sp.integrate(sp.diff(u, x), y)
print("  由 u_x 積分得 v =", v)
print("  檢查 CR: u_y + v_x =", sp.simplify(sp.diff(u, y) + sp.diff(v, x)))
print("  於是 f(z) = u + i v =", sp.simplify(u + sp.I * v), " （應等於 z^3）")
print("  與 z^3 之差 =", sp.simplify(u + sp.I * v - (x + sp.I * y)**3))
print()

# ---------- 3. 極大模原理：最大值只能在邊界取到 ----------
print("=== 3. 極大模原理 ===")
R = 2.0
tt = np.linspace(0, 2 * np.pi, 20001)
boundary = np.abs((R * np.exp(1j * tt))**2)
gx = np.linspace(-R, R, 401)
X, Y = np.meshgrid(gx, gx)
mask = (X**2 + Y**2) <= R**2 + 1e-12
G = np.abs((X + 1j * Y)**2)
print("  f(z) = z^2, |z| <= 2")
print("  邊界上 |f| 的最小/最大 = %.12f / %.12f" % (boundary.min(), boundary.max()))
print("  圓盤內部 |f| 的最大 = %.12f" % G[mask].max())
print("  內部最大值 <= 邊界最大值？", G[mask].max() <= boundary.max() + 1e-12)
print("  等號只在邊界成立（z = ±2 與 ±2i）：", np.isclose(G[mask].max(), boundary.max()))
print()

# ---------- 4. 恆等定理：全純函數由其在 R 上的值唯一決定 ----------
print("=== 4. 恆等定理（解析延拓的唯一性）===")
w = sp.Symbol('w')
n = sp.symbols('n', integer=True, nonnegative=True)
g = sp.summation(w**n / sp.factorial(n), (n, 0, sp.oo))
print("  g(w) = sum w^n/n! =", g)
print("  g(w) - exp(w) =", sp.simplify(g - sp.exp(w)))
print("  => f(w)=exp(w) 與 g(w) 在實軸上相同，故在全平面相同")
print()

=== 1. 調和性 (Laplace 方程) ===
  u = Re(z**3    ) = x*(x**2 - 3*y**2)      ;  u_xx + u_yy = 0
  u = Re(exp(z)  ) = exp(x)*cos(y)          ;  u_xx + u_yy = 0
  u = Re(1/z     ) = x/(x**2 + y**2)        ;  u_xx + u_yy = 0
  u = Re(log(z)  ) = log(x**2 + y**2)/2     ;  u_xx + u_yy = 0
  對照：u = |z|^2 (非全純) 的 Laplace = 4

=== 2. 調和共軛：u 決定 v ===
  u = x**3 - 3*x*y**2
  由 u_x 積分得 v = 3*x**2*y - y**3
  檢查 CR: u_y + v_x = 0
  於是 f(z) = u + i v = x**3 - 3*x*y**2 + I*y*(3*x**2 - y**2)  （應等於 z^3）
  與 z^3 之差 = 0

=== 3. 極大模原理 ===
  f(z) = z^2, |z| <= 2
  邊界上 |f| 的最小/最大 = 4.000000000000 / 4.000000000000
  圓盤內部 |f| 的最大 = 4.000000000000
  內部最大值 <= 邊界最大值？ True
  等號只在邊界成立（z = ±2 與 ±2i）： True

=== 4. 恆等定理（解析延拓的唯一性）===
  g(w) = sum w^n/n! = exp(w)
  g(w) - exp(w) = 0
  => f(w)=exp(w) 與 g(w) 在實軸上相同，故在全平面相同