Maupertuis' Principle¶

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

Principio di Maupertuis¶

Il principio di Maupertuis afferma che, per un sistema meccanico conservativo, il moto reale tra due configurazioni assegnate avviene lungo la traiettoria che rende stazionaria (tipicamente minima) una certa quantità detta $azione\; abbreviata$.

Il principio di Maupertuis è strettamente legato al principio di Hamilton, ma a differenza di quest'ultimo:

  • non coinvolge esplicitamente il tempo;
  • considera solo traiettorie a energia fissata;
  • ha una formulazione geometrica, interpretando il moto come una geodetica

in uno spazio con metrica dipendente dal potenziale.

----------------------------------------¶

Sia un sistema con coordinate generalizzate $q_i$ e momento coniugato $p_i$, soggetto a un'energia totale costante $E$. L'azione abbreviata è definita come: $$ \mathcal{S}_0 = \int_{q_1}^{q_2} \sum_i p_i \, dq_i $$

Il principio di Maupertuis si esprime allora come: $$ \delta \mathcal{S}_0 = \delta \int \sum_i p_i \, dq_i = 0 $$ dove la variazione è calcolata su tutte le traiettorie possibili che collegano i due punti nello spazio delle configurazioni, mantenendo costante l'energia $E$.

Nel caso di una particella di massa $m$ che si muove in un potenziale $V(q)$, il momento è: $$ p = \sqrt{2m\left(E - V(q)\right)} $$ e l'azione abbreviata diventa: $$ \mathcal{S}_0 = \int \sqrt{2m\left(E - V(q)\right)} \, ds $$ dove $ds$ è l'elemento di lunghezza lungo la traiettoria.

Il principio di Maupertuis è strettamente legato al principio di Hamilton, ma a differenza di quest'ultimo:

  • non coinvolge esplicitamente il tempo;
  • considera solo traiettorie a energia fissata;
  • ha una formulazione geometrica, interpretando il moto come una geodetica

in uno spazio con metrica dipendente dal potenziale.

Symbolic Approach¶

In [30]:
import sympy as sp 

def calculate_action_integral(L, t1, t2, q):
    """
    Compute the action integral over a given trajectory.
    param L: Lagrangian as a function of generalized coordinate and
    velocity.
        :param tl: Start time of the trajectory.
        :param t2: End time of the trajectory.
        :param q_t: Generalized coordinate as a function of time.
        :param q_dot_t: Derivative of generalized coordinate with respect to time.
    :return: 
        Calculated action integral.
    """
    t = sp.symbols('t')
    q_t = q(t)
    q_dot_t = sp.diff(q_t, t)
    L_subs = L.subs({q(t): q_t, sp.diff(q(t), t): q_dot_t})
    action_integral = sp.integrate(L_subs, (t, t1, t2))
    return action_integral


def derive_euler_lagrange(L, q):
    """
    Derive the Euler-Lagrange equation from a given Lagrangian.
        :param L: Lagrangian as a function of generalized coordinate and velocity.
        :param q: Generalized coordinate.
    :return: 
        Euler—Lagrange equation.
    """
    t = sp.symbols('t')
    q_t = q(t)
    q_dot_t = sp.diff(q_t, t)

    L_q = sp.diff(L, q_t)
    L_q_dot = sp.diff(L, q_dot_t)
    L_q_dot_diff = sp.diff(L_q_dot, t)

    return sp.simplify(L_q_dot_diff - L_q)


# Symbols
t = sp.symbols('t')
q = sp.Function('q')

# Energies
def kinetic_energy(v):
    m = sp.symbols('m')
    return sp.Rational(1, 2) * m * v**2

def potential_energy(x):
    k = sp.symbols('k')
    return sp.Rational(1, 2) * k * x**2

# Lagrangian
q_t = q(t)
q_dot_t = sp.diff(q_t, t)
L = kinetic_energy(q_dot_t) - potential_energy(q_t)

# Action integral
action_integral_example = calculate_action_integral(L, 0, 1, q)

# Euler–Lagrange equation
euler_lagrange_eq = derive_euler_lagrange(L, q)

print("Action Integral:", action_integral_example)  
print("Euler-Lagrange Equation:", euler_lagrange_eq)

Action Integral: -Integral(k*q(t)**2, (t, 0, 1))/2 - Integral(-m*Derivative(q(t), t)**2, (t, 0, 1))/2
Euler-Lagrange Equation: k*q(t) + m*Derivative(q(t), (t, 2))

Numeric Approach¶

In [47]:
# Parametri numerici
m_val = 1
k_val = 4

# Traiettoria di prova
q_trial = sp.sin(t)
q_dot_trial = sp.diff(q_trial, t)

L_numeric = (
    kinetic_energy(q_dot_trial).subs(sp.symbols('m'), m_val)
    - potential_energy(q_trial).subs(sp.symbols('k'), k_val)
)

action_numeric = sp.integrate(L_numeric, (t, 0, sp.pi))
action_numeric
Out[47]:
$\displaystyle - 3 \pi$
In [34]:
euler_lagrange_eq
Out[34]:
$\displaystyle k q{\left(t \right)} + m \frac{d^{2}}{d t^{2}} q{\left(t \right)}$

Arco di parabola con estremi nulli¶

In [49]:
q_parab = t * (sp.pi - t)

S_parab = sp.integrate(
    kinetic_energy(sp.diff(q_parab, t)) - potential_energy(q_parab),
    (t, 0, sp.pi)
)

S_parab

derive_euler_lagrange(L, q)
Out[49]:
$\displaystyle k q{\left(t \right)} + m \frac{d^{2}}{d t^{2}} q{\left(t \right)}$
In [ ]: