Constraints and Dirac Brackets¶

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

Poisson Bracket¶

$$\large \{f,g\}_{PB}$$
  • Fisicamente misura quanto $f$ cambia sotto la trasformazione canonica generata da $g$
  • oppure misura la non-commutatività classica delle osservabili
  • nel nostro caso, in forma simbolica :
$$\large \{q+p,q-p\}=-2$$
  • ma noi lo valutiamo in un punto ben specifico $\rightarrow$ otteniamo un numero

Dirac bracket: perché è diverso¶

  • Poisson brackets non rispettano automaticamente i vincoli
  • possono generare evoluzioni che escono dalla superficie vincolata

Dirac bracket¶

$$\large \{f,g\}_D$$
  • è costruito per eliminare i gradi di libertà non fisici
  • per garantire che i vincoli valgano sempre
  • per proiettare la dinamica sulla superficie dei vincoli
  • matematicamente :
$$\large \{f,g\}_D​=\{f,g\}−\{f,χ_i​\}C_{ij}^{−1}​\{χ_j​,g\}$$

Interpretazione fisica finale¶

  • I vincoli eliminano gradi di libertà
  • Le osservabili non commutano più come prima
  • Il Dirac bracket è la struttura corretta per:
    • sistemi con vincoli di seconda classe
    • quantizzazione consistente

“Quando un sistema hamiltoniano è fortemente vincolato, la struttura canonica dello spazio delle fasi cambia, e il Dirac bracket sostituisce il Poisson bracket come misura fisica delle variazioni osservabili.”

L'esercizio implementa un sistema hamiltoniano con vincoli di seconda classe in Python, e mostra come calcolare sia i Poisson bracket sia i Dirac bracket.

Definizione del sistema¶

Il sistema è definito da:

  • Un insieme di \textbf{vincoli} $\phi_i(q,p)=0$, che limitano lo spazio delle fasi.
  • Una \textbf{Hamiltoniana} $H(q,p)$, funzione delle coordinate $q$ e dei momenti $p$, che determina l'evoluzione dinamica.

In questo esercizio, i vincoli sono rappresentati come funzioni numeriche di $(q,p)$, e la Hamiltoniana come funzione di esempio:

$$\large \phi_1(q,p) = q^2 + p^2 - 1, \quad \phi_2(q,p) = q \, p - \frac{1}{2}, \quad H(q,p) = \frac{p^2}{2} + \frac{q^2}{2}. $$

Calcolo della matrice dei vincoli¶

La $\textbf{matrice dei vincoli}$ $C_{ij}$ è definita tramite i Poisson bracket dei vincoli stessi:

$$\large C_{ij} = \{ \phi_i, \phi_j \}. $$

In codice, questa matrice viene calcolata dalla funzione $\texttt{compute\_constraint\_matrix}$.

Poisson bracket¶

Il $\textbf{Poisson bracket}$ tra due osservabili $f(q,p)$ e $g(q,p)$ è definito come:

$$\large \{ f, g \} = \frac{\partial f}{\partial q} \frac{\partial g}{\partial p} - \frac{\partial f}{\partial p} \frac{\partial g}{\partial q}. $$

In questo esercizio, il calcolo del Poisson bracket è implementato come placeholder numerico, ma concettualmente rappresenta la struttura fondamentale della dinamica hamiltoniana.

Dirac bracket¶

Quando il sistema è vincolato, i Poisson bracket non rispettano i vincoli durante l'evoluzione.
Il $\textbf{Dirac bracket}$ corregge questa situazione:

$$\large \{ f, g \}_D = \{ f, g \} - \sum_{i,j} \{ f, \phi_i \} (C^{-1})_{ij} \{ \phi_j, g \}, $$

dove $C^{-1}$ è l'inversa della matrice dei vincoli.
Il Dirac bracket garantisce che:

$$\large \{ f, \phi_i \}_D = 0 \quad \forall i, $$

cioè i vincoli sono preservati esattamente durante l’evoluzione.

In codice, questa operazione è realizzata dalla funzione £\texttt{dirac_bracket}$.

Esecuzione dell'esercizio¶

  1. Si definiscono vincoli e Hamiltoniana.
  2. Si calcola la matrice dei vincoli.
  3. Si calcola un esempio di Poisson bracket tra due funzioni $f$ e $g$.
  4. Si calcola un esempio di Dirac bracket tra le stesse funzioni.
  5. In questo esercizio, i due bracket risultano numericamente differenti, evidenziando l'effetto dei vincoli sulla dinamica del sistema.

Osservazioni didattiche¶

  • Il Poisson bracket descrive la dinamica nello spazio delle fasi “esteso”, senza vincoli.
  • Il Dirac bracket riduce la dinamica allo \textbf{spazio delle fasi fisicamente permesso}, eliminando direzioni non ammissibili.
  • L'esercizio mostra in modo concreto come implementare questo formalismo in Python, anche se il calcolo effettivo dei bracket è qui rappresentato come valori numerici fittizi.

Punto vincolato sulla sfera di raggio $R$¶

Significato fisico¶

  • La differenza tra i due bracket rappresenta quanto la dinamica “viene corretta” dai vincoli.
  • In altre parole, il Dirac bracket mostra l’evoluzione effettiva della particella sulla sfera, mentre il Poisson bracket ignora che non può muoversi radialmente.
In [43]:
import numpy as np

# =========================
# 1. Poisson bracket
# =========================
def poisson_bracket(f, g, q, p, eps=1e-6):
    """
    Poisson bracket numerico {f, g}
    """
    pb = 0.0
    n = len(q)

    for i in range(n):
        dq = np.zeros(n)
        dp = np.zeros(n)
        dq[i] = eps
        dp[i] = eps

        df_dq = (f(q + dq, p) - f(q - dq, p)) / (2 * eps)
        df_dp = (f(q, p + dp) - f(q, p - dp)) / (2 * eps)

        dg_dq = (g(q + dq, p) - g(q - dq, p)) / (2 * eps)
        dg_dp = (g(q, p + dp) - g(q, p - dp)) / (2 * eps)

        pb += df_dq * dg_dp - df_dp * dg_dq

    return pb

# =========================
# 2. Vincoli della sfera
# =========================
def f(q, p):
    return np.dot(q, p)  # funzione radiale

def g(q, p):
    return p[0]           # componente x del momento

# =========================
# 3. Matrice dei vincoli
# =========================
def constraint_matrix(q, p, R):
    C = np.zeros((2, 2))

    def f1(q, p): return phi1(q, p, R)
    def f2(q, p): return phi2(q, p)

    C[0, 0] = poisson_bracket(f1, f1, q, p)
    C[0, 1] = poisson_bracket(f1, f2, q, p)
    C[1, 0] = poisson_bracket(f2, f1, q, p)
    C[1, 1] = poisson_bracket(f2, f2, q, p)

    return C

# =========================
# 4. Dirac bracket
# =========================
def dirac_bracket(f, g, q, p, R):
    def f1(q, p): return phi1(q, p, R)
    def f2(q, p): return phi2(q, p)

    phi = [f1, f2]

    C = constraint_matrix(q, p, R)
    C_inv = np.linalg.inv(C)

    correction = 0.0
    for a in range(2):
        for b in range(2):
            correction += (
                poisson_bracket(f, phi[a], q, p)
                * C_inv[a, b]
                * poisson_bracket(phi[b], g, q, p)
            )

    return poisson_bracket(f, g, q, p) - correction

# Parametri
R = 1.0
q = np.array([1.0, 0.0, 0.0])
p = np.array([0.5, 0.2, 0.0])

pb = poisson_bracket(f, g, q, p)  # Poisson bracket
db = dirac_bracket(f, g, q, p, R) # Dirac bracket
print(f"Poisson Bracket = {pb:.2f}")
print(f"Dirac Bracket = {db:.2f}")

Poisson Bracket = 0.50
Dirac Bracket = 0.00
In [ ]: