Hamiltonian Formulation of Fields Theories¶

da PowerShell -- jupyter nbconvert --to html notebook.ipynb

Evoluzione Hamiltoniana di un campo scalare libero in una dimensione¶

Consideriamo un campo scalare reale $\phi(x,t)$ definito su una dimensione spaziale, con densità di Lagrangiana data da $$\large \mathcal{L} = \frac{1}{2} \left( \dot{\phi}^2 - (\partial_x \phi)^2 - m^2 \phi^2 \right), $$ dove $m$ è la massa del campo.

Momento coniugato e densità Hamiltoniana¶

Il momento coniugato al campo è definito come $$\large \pi(x,t) = \frac{\partial \mathcal{L}}{\partial \dot{\phi}} = \dot{\phi}(x,t). $$

La densità Hamiltoniana si ottiene tramite trasformazione di Legendre: $$\large \mathcal{H} = \pi \dot{\phi} - \mathcal{L} = \frac{1}{2} \left( \pi^2 + (\partial_x \phi)^2 + m^2 \phi^2 \right). $$

Equazioni di Hamilton¶

Le equazioni di Hamilton per il campo sono $$\large \begin{align} \dot{\phi}(x,t) &= \frac{\delta \mathcal{H}}{\delta \pi(x,t)}, \\ \dot{\pi}(x,t) &= -\frac{\delta \mathcal{H}}{\delta \phi(x,t)}. \end{align} $$

Nel caso del campo scalare libero si ottiene esplicitamente: $$\large \begin{align} \dot{\phi}(x,t) &= \pi(x,t), \\ \dot{\pi}(x,t) &= \partial_x^2 \phi(x,t) - m^2 \phi(x,t). \end{align} $$

Combinando le due equazioni si recupera l'equazione di Klein--Gordon: $$\large \left( \partial_t^2 - \partial_x^2 + m^2 \right) \phi(x,t) = 0. $$

Discretizzazione spaziale¶

Si introduce una griglia spaziale uniforme: $$\large x_i = x_{\min} + i \, \Delta x, \qquad i = 0, \dots, N-1, $$ e si approssima il Laplaciano tramite differenze finite centrali: $$\large \partial_x^2 \phi(x_i) \approx \frac{\phi_{i+1} - 2\phi_i + \phi_{i-1}}{(\Delta x)^2}. $$

Schema di integrazione temporale¶

L'evoluzione temporale è implementata usando uno schema di Eulero esplicito: $$\large \begin{align} \phi^{n+1}_i &= \phi^n_i + \Delta t \, \pi^n_i, \\ \pi^{n+1}_i &= \pi^n_i + \Delta t \left( \partial_x^2 \phi^n_i - m^2 \phi^n_i \right), \end{align} $$ dove $\Delta t$ è il passo temporale.

Condizioni iniziali¶

Le condizioni iniziali sono assegnate come: $$\large \begin{align} \phi(x,0) &= \phi_0(x), \\ \pi(x,0) &= 0, \end{align} $$ con $\phi_0(x)$ una configurazione localizzata (ad esempio una gaussiana).

Osservazioni¶

Lo schema presentato è semplice ma non simplettico; per simulazioni di lungo tempo è preferibile adottare integratori simplettici (Leapfrog o Störmer--Verlet), che conservano meglio l'energia Hamiltoniana del sistema.

In [26]:
import numpy as np

def laplacian_1d(phi, dx):
    return np.gradient(np.gradient(phi, dx), dx)

def compute_conjugate_momentum(lagrangian_density, phi_dot):
    '''
    Compute the conjugate momentum density for a given Lagrangian.
        :param Iagrangian_density: Function representing the Lagrangian density.
        :param phi_dot: Time derivative of the field.
    :return: 
        Conjugate momentum density.
    '''
    return np.gradient(lagrangian_density, phi_dot)

def hamiltonian_density(phi, pi, nabla_phi, mass):
    '''
    Compute the Hamiltonian density for a scalar field.
        :param phi: Scalar field.
        :param pi: Conjugate momentum.
        :param nabla_phi: Spatial derivative of the field.
        :param mass: Mass of the field.
    :return: 
        Hamiltonian density.
    '''
    return 0.5 * (pi**2 + nabla_phi**2 + mass**2 * phi**2)

def hamiltons_equations(phi, pi, delta_h_dphi, delta_h_dpi):
    '''
    Evaluate Hamilton s equations of motion for the field theory.
        :param phi: Field variable.
        :param pi: Conjugate momentum.
        :param delta_h_dphi: Functional derivative of Hamiltonian density wrt phi.
        :param delta_h_dpi: Functional derivative of Hamiltonian density wrt pi.
    :return: 
        Time derivatives of phi and pi.
    '''
    phi_dot = delta_h_dpi
    pi_dot = -delta_h_dphi
    return phi_dot, pi_dot

def numerical_hamiltonian_evolution(initial_phi, initial_pi, num_steps, dt, dx, mass=1.0):
    '''
    Numerically evolve the field configuration using Hamiltonian principles.
        :param initial_phi: Initial field configuration.
        :param initial_pi: Initial momentum configuration.
        :param num_steps: Number of time steps to evolve.
        :param dt: Time step size.
        :param dx: Space step size.
        :param mass: Mass of the field.
    :return: 
        Evolved field and momentum.
    '''
    phi = initial_phi.copy()
    pi = initial_pi.copy()

    for _ in range(num_steps):
        # Hamilton equations for free scalar field
        phi_dot = pi
        pi_dot = laplacian_1d(phi, dx) - mass**2 * phi

        # Explicit Euler (simple but not symplectic)
        phi += dt * phi_dot
        pi += dt * pi_dot

    return phi, pi

# Grid
N = 100
x = np.linspace(-1, 1, N)
dx = x[1] - x[0]

# Initial conditions
initial_phi = np.exp(-10 * x**2)   # localized bump
initial_pi = np.zeros_like(x)

# Evolve
evolved_phi, evolved_pi = numerical_hamiltonian_evolution(
    initial_phi,
    initial_pi,
    num_steps=1000,
    dt=0.001,
    dx=dx,
    mass=1.0
)

print("Evolved Field Configuration:", evolved_phi[0:12])
print('')
print("Evolved Momentum Configuration:", evolved_pi[0:12])

Evolved Field Configuration: [0.43661803 0.43266718 0.42045937 0.40827887 0.38864683 0.36908439
 0.34355258 0.31815493 0.28871686 0.25950018 0.22833867 0.19749506]

Evolved Momentum Configuration: [-0.26014165 -0.46898557 -0.67708424 -0.8650818  -1.05197323 -1.20187306
 -1.35009972 -1.45014102 -1.54797241 -1.59344285 -1.63645937 -1.62976573]
In [ ]: