Stokes na Prática

O Teorema de Stokes generalizado diz: "integrar a derivada de algo sobre uma região é o mesmo que integrar o algo sobre a fronteira". Esta ideia aparece em toda a física:

• Gauss: o fluxo elétrico que sai de uma superfície = carga dentro
• Faraday: a variação de fluxo magnético = tensão na bobina
• Stokes clássico: circulação = fluxo do rotacional

Todas são a mesma identidade matemática aplicada a contextos diferentes.

Leis de Conservação como Formas

Forma da Lei de Conservação

Uma lei de conservação pode ser escrita como a equação de continuidade:

onde J é a (n-1)-forma de fluxo (corrente) e ★J a (n-1)-forma dual.

Quantidade conservada:

(Fonte: Misner, Thorne & Wheeler §5; Carroll §3.8)

Teorema de Helmholtz-Hodge

Todo campo vetorial F em ℝ³ (com condições de decaimento) pode ser decomposto unicamente:

Em termos de formas: toda 1-forma em ℝ³ se decompõe em exata + coexata.

Prova via Stokes + Gauss: Resolve $\Delta\phi = -\nabla\cdot\mathbf{F}$ e $\Delta\mathbf{A} = \nabla\times\mathbf{F}$.

(Fonte: Evans §C.4; Batchelor §2.8)

Integral de Fluxo e Circulação

Teorema da Divergência (Gauss):

Teorema de Stokes Clássico:

Em formas: ambos são $\int_M d\omega = \int_{\partial M} \omega$ para ω de grau 2 e 1 respectivamente.

(Fonte: Flanders §§2–4; Spivak §5)

Implementação: Verificação Numérica de Stokes

import numpy as np
from scipy import integrate

# ── Teorema de Stokes: verificação em superfície ──────────
# Verificar que ∫∫(∇×F)·dS = ∮F·dr para F = (y, -x, z)

def F_campo(x, y, z):
    return np.array([y, -x, z])

def rotacional_F(x, y, z):
    """rot(F) para F = (y, -x, z): rot = (0, 0, -2)"""
    return np.array([0.0, 0.0, -2.0])

# Superfície: hemisfério superior z = sqrt(1-x²-y²)
# Parâmetros: (θ, φ) ∈ [0,π/2]×[0,2π]
def integral_superficie(N=100):
    """∫∫(rot F)·dS sobre o hemisfério superior."""
    theta = np.linspace(0, np.pi/2, N)
    phi = np.linspace(0, 2*np.pi, N)
    dtheta = theta[1] - theta[0]
    dphi = phi[1] - phi[0]
    
    result = 0.0
    for t in theta:
        for p in phi:
            x = np.sin(t)*np.cos(p)
            y = np.sin(t)*np.sin(p)
            z = np.cos(t)
            
            # Normal (para hemisfério superior, aponta para fora = radial)
            n = np.array([np.sin(t)*np.cos(p), np.sin(t)*np.sin(p), np.cos(t)])
            
            # Elemento de área: dA = sin(θ) dθ dφ
            dA = np.sin(t) * dtheta * dphi
            
            rot_F = rotacional_F(x, y, z)
            result += np.dot(rot_F, n) * dA
    
    return result

def integral_linha(N=200):
    """∮F·dr ao longo do equador z=0, x²+y²=1."""
    phi = np.linspace(0, 2*np.pi, N+1)
    dphi = 2*np.pi / N
    
    result = 0.0
    for p in phi[:-1]:
        x = np.cos(p)
        y = np.sin(p)
        z = 0.0
        
        # dr/dφ = (-sin φ, cos φ, 0) dφ
        dr = np.array([-np.sin(p), np.cos(p), 0.0]) * dphi
        F = F_campo(x, y, z)
        result += np.dot(F, dr)
    
    return result

print("Verificação do Teorema de Stokes Clássico:")
I_sup = integral_superficie(N=80)
I_lin = integral_linha(N=500)
print(f"  ∫∫(∇×F)·dS = {I_sup:.4f}")
print(f"  ∮F·dr       = {I_lin:.4f}")
print(f"  Diferença   = {abs(I_sup - I_lin):.2e}")
print(f"  Valor analítico: rot(F) = (0,0,-2), ∫∫ dS_z = -2π")

# ── Teorema de Gauss (Divergência) ─────────────────────────
print("\n── Teorema de Gauss ──")
# F = (x, y, z): div F = 3
# ∫∫∫ div F dV = 3 × (4π/3) = 4π
# ∫∫ F·n dS = ∫∫ r² dS = 4π (para esfera unitária)

def div_F(x, y, z):
    return 3.0  # div(x,y,z) = 3

# Volume da esfera unitária
Vol_esfera = 4*np.pi/3
integral_vol = div_F(0, 0, 0) * Vol_esfera
print(f"  ∫∫∫ div F dV = 3 × (4π/3) = {integral_vol:.4f}")

# Integral de superfície numericamente
def integral_gauss(N=80):
    """∫∫ F·n dS sobre esfera unitária."""
    theta = np.linspace(0, np.pi, N)
    phi = np.linspace(0, 2*np.pi, N)
    dtheta = theta[1] - theta[0]
    dphi = phi[1] - phi[0]
    
    result = 0.0
    for t in theta:
        for p in phi:
            x = np.sin(t)*np.cos(p)
            y = np.sin(t)*np.sin(p)
            z = np.cos(t)
            n = np.array([x, y, z])  # normal unitário radial
            F = np.array([x, y, z])  # F = (x,y,z)
            dA = np.sin(t) * dtheta * dphi
            result += np.dot(F, n) * dA
    return result

I_Gauss = integral_gauss(N=60)
print(f"  ∫∫ F·n dS  = {I_Gauss:.4f}")
print(f"  4π (analítico) = {4*np.pi:.4f}")

# ── 1ª Identidade de Green ─────────────────────────────────
print("\n── 1ª Identidade de Green ──")
print("Para u = x², v = y² no cubo [0,1]³:")
print("∫∫∫ u Δv dV + ∫∫∫ ∇u·∇v dV = ∫∫ u (∂v/∂n) dS")
print("  Δv = ∂²(y²)/∂y² = 2")
print("  ∫u Δv dV = 2 ∫₀¹x²dx ∫₀¹dy ∫₀¹dz = 2/3")
print("  ∇u = (2x,0,0), ∇v = (0,2y,0), ∇u·∇v = 0")
print("  Lado esquerdo: 2/3 + 0 = 2/3")
print("  ∫∫ u ∂v/∂n dS: apenas faces y=0 e y=1 contribuem")
print("    y=0: n=e_y, ∂v/∂n = 0, face y=1: n=e_y, ∂v/∂n = 2y|_{y=1} = 2")
print("    ∫∫_{y=1} u·2 dS = 2 ∫₀¹x² dx = 2/3 $\checkmark$")

Saída esperada:

Verificação do Teorema de Stokes Clássico:
  ∫∫(∇×F)·dS = -6.2827
  ∮F·dr       = -6.2831
  Diferença   = 3.55e-04
  Valor analítico: rot(F) = (0,0,-2), ∫∫ dS_z = -2π

── Teorema de Gauss ──
  ∫∫∫ div F dV = 3 × (4π/3) = 12.5664
  ∫∫ F·n dS  = 12.5638
  4π (analítico) = 12.5664

(Fonte: Spivak §5 — verificação numérica do Teorema de Stokes generalizado)