O Que São Tensores?

Escalares, vetores e matrizes são casos particulares de tensores. Um tensor é um objeto matemático que generaliza estes conceitos de uma maneira que não depende do sistema de coordenadas escolhido — propriedade fundamental na física.

• Escalar (tensor de ordem 0): temperatura, massa
• Vetor (tensor de ordem 1): força, velocidade
• Matriz/tensor de 2ª ordem: tensor de tensões, tensor de inércia

Albert Einstein introduziu a convenção de soma implícita (notação de Einstein) que simplifica enormemente as operações tensoriais, tornando as equações mais concisas e transparentes.

Álgebra Tensorial

Operações Fundamentais

Produto tensorial: Se T é (r,s) e S é (p,q):

Contração: Fixe um índice contravariante e um covariante iguais e some:

Reduz o tipo de (r,s) a (r-1,s-1).

Traço: Contração total de um tensor (2,0): $T^i_{\;i} = g_{ij}T^{ij}$.

Simetrização e antissimetrização:

(Fonte: Carroll §1.4; Misner, Thorne & Wheeler §3.5)

Tensores Especiais

Delta de Kronecker: $\delta^i_j = \begin{cases} 1 & i=j \\ 0 & i\neq j \end{cases}$ — tensor de tipo (1,1).

Símbolo de Levi-Civita: $\varepsilon_{ijk}$ = +1 se ijk é permutação par de 123, -1 se ímpar, 0 se repete.

Tensor de Levi-Civita (tensor completamente antissimétrico):

(Fonte: Carroll §2.8; Misner, Thorne & Wheeler §3.7)

Tensores em Coordenadas Curvilíneas

Coordenadas esféricas ($r, \theta, \phi$): tensor métrico:

Normas e produtos escalares:

(Fonte: Misner, Thorne & Wheeler §8; Schutz §5)

Implementação: Operações Tensoriais com NumPy

import numpy as np

# ── Tensor métrico em coordenadas esféricas ─────────────────
def metrica_esferica(r, theta):
    """Tensor métrico em coordenadas (r, θ, φ)."""
    g = np.zeros((3, 3))
    g[0, 0] = 1.0          # g_rr
    g[1, 1] = r**2         # g_θθ
    g[2, 2] = (r * np.sin(theta))**2  # g_φφ
    return g

r, theta = 2.0, np.pi/4
g = metrica_esferica(r, theta)
g_inv = np.linalg.inv(g)

print("Tensor métrico em (r=2, θ=π/4):")
print(g)
print(f"det(g) = {np.linalg.det(g):.4f}")
print(f"sqrt(det(g)) = {np.sqrt(np.linalg.det(g)):.4f}")

# Verificar: g_ik * g^kj = delta^i_j
identidade = g @ g_inv
print(f"\ng * g_inv = \n{np.round(identidade, 10)}")

# ── Contração: produto escalar em coordenadas curvilíneas ──
# v^i = (1, 0.5, 0.2) em coordenadas esféricas
v_contra = np.array([1.0, 0.5, 0.2])

# Abaixar índice: v_i = g_ij * v^j
v_cov = g @ v_contra
print(f"\nVetor contravariante v^i = {v_contra}")
print(f"Vetor covariante v_i = g_ij v^j = {v_cov}")

# Norma: g_ij v^i v^j
norma_sq = v_cov @ v_contra  # = g_ij v^i v^j
print(f"|v|² = g_ij v^i v^j = {norma_sq:.6f}")

# ── Símbolo de Levi-Civita e produto vetorial ──────────────
def levi_civita_3d():
    eps = np.zeros((3, 3, 3))
    # Permutações pares: +1, ímpares: -1
    eps[0,1,2] = eps[1,2,0] = eps[2,0,1] = 1.0
    eps[2,1,0] = eps[0,2,1] = eps[1,0,2] = -1.0
    return eps

eps = levi_civita_3d()

# Produto vetorial: (A × B)^k = ε^ijk A_i B_j
A = np.array([1.0, 2.0, 3.0])
B = np.array([4.0, 5.0, 6.0])
# Em coord. cartesianas: g_ij = δ_ij, então v^i = v_i

cross_tensor = np.einsum('ijk,i,j->k', eps, A, B)
cross_numpy = np.cross(A, B)
print(f"\nA × B via tensor Levi-Civita: {cross_tensor}")
print(f"A × B via numpy: {cross_numpy}")
print(f"Diferença: {np.max(np.abs(cross_tensor - cross_numpy)):.2e}")

# ── Símbolos de Christoffel para a esfera S² ──────────────
# Métrica: g = diag(1, sin²θ) em (θ, φ)
# Símbolo não-nulo: Γ^θ_φφ = -sinθ cosθ, Γ^φ_θφ = Γ^φ_φθ = cosθ/sinθ

def christoffel_esfera(theta):
    """Símbolos de Christoffel para S² com métrica diag(1, sin²θ)."""
    # Γ^i_jk: índices (contravariante, covariante, covariante)
    Gamma = np.zeros((2, 2, 2))
    # Γ^0_11 = Γ^θ_φφ = -sinθ cosθ
    Gamma[0, 1, 1] = -np.sin(theta) * np.cos(theta)
    # Γ^1_01 = Γ^1_10 = Γ^φ_θφ = cosθ/sinθ
    if abs(np.sin(theta)) > 1e-10:
        cot = np.cos(theta) / np.sin(theta)
        Gamma[1, 0, 1] = cot
        Gamma[1, 1, 0] = cot
    return Gamma

theta_test = np.pi/3
Gamma = christoffel_esfera(theta_test)
print(f"\nChristoffel em S² para θ = π/3:")
print(f"Γ^θ_φφ = {Gamma[0,1,1]:.4f} (deve ser {-np.sin(theta_test)*np.cos(theta_test):.4f})")
print(f"Γ^φ_θφ = {Gamma[1,0,1]:.4f} (deve ser {np.cos(theta_test)/np.sin(theta_test):.4f})")

# ── Transformação tensorial ─────────────────────────────────
print("\n── Transformação de Coordenadas ──")
# Rotação 2D: x̃ = R x, onde R = [[cos θ, sin θ], [-sin θ, cos θ]]
theta_rot = np.pi / 4
R = np.array([[np.cos(theta_rot), np.sin(theta_rot)],
              [-np.sin(theta_rot), np.cos(theta_rot)]])

# Tensor (exemplo: tensor de inércia 2x2)
T = np.array([[2.0, 1.0], [1.0, 3.0]])

# Transformação: T̃^ij = R^i_k R^j_l T^kl = R T R^T
T_transformado = R @ T @ R.T

print(f"Tensor original: \n{T}")
print(f"Tensor rotacionado (θ=π/4): \n{np.round(T_transformado, 4)}")
print(f"Traço (invariante): {np.trace(T):.4f} = {np.trace(T_transformado):.4f}")
print(f"Det (invariante): {np.linalg.det(T):.4f} = {np.linalg.det(T_transformado):.4f}")

Saída esperada:

Tensor métrico em (r=2, θ=π/4):
[[1.  0.  0. ]
 [0.  4.  0. ]
 [0.  0.  2. ]]
det(g) = 8.0000
sqrt(det(g)) = 2.8284

Traço (invariante): 5.0000 = 5.0000
Det (invariante): 5.0000 = 5.0000

(Fonte: Carroll §1 — operações tensoriais básicas com NumPy)