Canonical Quantization¶

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

Quantizzazione canonica in Python¶

Il codice Python fornito implementa, in forma didattica e semplificata, diversi concetti fondamentali della meccanica classica e quantistica:

Hamiltoniana classica¶

Si definisce l'Hamiltoniana classica come $$\large H(p,q) = T(p,q) + V(q), $$ dove $T$ è l'energia cinetica e $V$ il potenziale.
Nel codice: $$\large T(p,q) = \frac{p^2}{2m}, \qquad V(q) = \frac{1}{2} q^2, $$ che corrisponde a un oscillatore armonico con massa $m=1$.

Equazioni di Hamilton¶

Le equazioni canoniche sono $$\large \dot{q} = \frac{\partial H}{\partial p}, \qquad \dot{p} = -\frac{\partial H}{\partial q}. $$ Nel codice queste derivate sono approssimate numericamente con $\texttt{numpy.gradient}$, quindi il risultato è una discretizzazione molto rozza delle equazioni del moto.

Quantizzazione canonica¶

La quantizzazione canonica sostituisce le variabili classiche con operatori: $$\large q \rightarrow \hat{q}, \qquad p \rightarrow \hat{p}, $$ imponendo le relazioni di commutazione canoniche: $$\large [\hat{q}, \hat{p}] = i \hbar. $$ Nel codice questo è simulato in modo simbolico con una funzione $\texttt{commutator}$, senza una vera rappresentazione operatoriale nello spazio di Hilbert.

Equazione di ${Schr\ddot{o}dinger}$¶

L'evoluzione temporale dello stato quantistico $\psi(t)$ è data da $$\large i\hbar \frac{\partial}{\partial t} \psi(t) = \hat{H} \psi(t). $$ La soluzione formale è $$\large \psi(t) = e^{-\frac{i}{\hbar} \hat{H} t} \psi(0). $$ Nel codice l'operatore di evoluzione temporale è calcolato tramite la matrice esponenziale: $$\large U(t) = \exp\!\left(-\frac{i}{\hbar} \hat{H} t \right). $$

Integrale sui cammini (Path Integral)¶

L'azione classica per una traiettoria $q(t)$ è $$\large S[q] = \int_{t_0}^{t_1} \left( \frac{1}{2} m \dot{q}^2 - V(q) \right) dt. $$ Nel codice l'integrale è approssimato numericamente con la regola dei trapezi.

Ambiguità di ordinamento degli operatori¶

Poiché $\hat{q}$ e $\hat{p}$ non commutano, un'espressione classica come $pq$ non ha un'unica quantizzazione.
Una scelta comune è la simmetrizzazione di Weyl: $$\large \frac{1}{2} (\hat{p}\hat{q} + \hat{q}\hat{p}). $$ Il codice implementa proprio questa simmetrizzazione.

Conclusione¶

Il programma è una dimostrazione concettuale (non fisicamente rigorosa) dei passi della quantizzazione canonica:

  • definizione della dinamica classica tramite Hamiltoniana,
  • passaggio a operatori quantistici e commutatori,
  • evoluzione tramite l'equazione di $Schr\ddot{o}dinger$,
  • formulazione alternativa tramite integrale sui cammini,
  • problema dell'ordinamento degli operatori.

Si tratta quindi di un ``mini laboratorio'' computazionale che illustra l'intero ponte concettuale tra meccanica classica e quantistica.

Struttura generale¶

Il codice implementa una catena concettuale che va dalla meccanica classica alla meccanica quantistica:

$$\large \text{Meccanica Classica} \;\;\rightarrow\;\; \text{Struttura Hamiltoniana} \;\;\rightarrow\;\; \text{Quantizzazione canonica} \;\;\rightarrow\;\; \text{Dinamica quantistica} \;\;\rightarrow\;\; \text{Integrali di cammino} $$

Hamiltoniana classica¶

Si definisce l'Hamiltoniana classica come:

$$\large H(p,q) = T(p,q) + V(q) $$

Nel codice: $$\large T(p,q) = \frac{p^2}{2m}, \qquad V(q) = \frac{1}{2}q^2 $$

quindi:

$$\large H(p,q) = \frac{p^2}{2m} + \frac{1}{2}q^2 $$

che corrisponde all'oscillatore armonico classico con $m=1$.

Equazioni di Hamilton¶

Le equazioni del moto sono:

$$\large \dot{q} = \frac{\partial H}{\partial p}, \qquad \dot{p} = -\frac{\partial H}{\partial q} $$

cioè la struttura fondamentale della dinamica canonica su spazio delle fasi $(q,p)$.

Il codice implementa una versione numerica discreta di: $$\large \dot{q}(t), \dot{p}(t) $$

Quantizzazione canonica¶

La quantizzazione canonica sostituisce le variabili classiche con operatori:

$$\large q \rightarrow \hat{q}, \qquad p \rightarrow \hat{p} $$

con le relazioni di commutazione canoniche:

$$\large [\hat{q}, \hat{p}] = i\hbar $$

che definiscono la struttura non commutativa dello spazio degli operatori quantistici.

Equazione di Schrödinger¶

L'evoluzione temporale dello stato quantistico $\psi(t)$ è data da:

$$\large i\hbar \frac{\partial}{\partial t} \psi(t) = \hat{H}\psi(t) $$

La soluzione formale è:

$$\large \psi(t) = U(t)\psi(0) $$

con operatore di evoluzione:

$$\large U(t) = e^{-\frac{i}{\hbar}\hat{H}t} $$

Nel codice:

$$\large U = \exp\left(-\frac{i}{\hbar} H_{\text{operator}} t \right) $$

Formulazione a integrale di cammino¶

L'azione classica è:

$$\large S[q(t)] = \int_{t_0}^{t_1} \left( \frac{1}{2}m \dot{q}^2 - V(q) \right)\, dt $$

che è l'oggetto centrale della formulazione di Feynman:

$$\large \mathcal{Z} = \int \mathcal{D}q \; e^{\frac{i}{\hbar}S[q]} $$

Il codice calcola una discretizzazione numerica di:

$$\large S[q] \approx \int (T - V)\, dt $$

Ambiguità di ordinamento operatoriale¶

Poiché:

$$\large [\hat{q},\hat{p}] \neq 0 $$

le espressioni del tipo:

$$\large \hat{p}\hat{q} $$

non sono univoche. Il codice usa la simmetrizzazione di Weyl:

$$\large \hat{O}_{sym} = \frac{1}{2}(\hat{p}\hat{q} + \hat{q}\hat{p}) $$

che è una prescrizione standard nella quantizzazione canonica.

Interpretazione fisica¶

L’esercizio rappresenta simbolicamente:

  • costruzione dell'Hamiltoniana classica
  • dinamica classica nello spazio delle fasi
  • passaggio classico $\rightarrow$ quantistico
  • struttura non-commutativa degli operatori
  • evoluzione quantistica unitaria
  • formulazione alternativa tramite azione
  • problema dell’ordinamento operatoriale

In forma compatta:

$$\large (q,p) \;\longrightarrow\; (\hat{q},\hat{p}) \;\;\Rightarrow\;\; [\hat{q},\hat{p}] = i\hbar \;\;\Rightarrow\;\; i\hbar \partial_t \psi = \hat{H}\psi \;\;\Rightarrow\;\; \psi(t) = e^{-i\hat{H}t/\hbar}\psi(0) $$

L'esercizio non si propone di risolvere il cammino di Feynman, ma solo di impostare una via concettuale¶

In [7]:
import numpy as np
from scipy.linalg import expm
from scipy.integrate import trapezoid

def classical_hamiltonian(T, V, p, q):
    """
    Calculate the classical Hamiltonian of a system.
        :param T: Kinetic energy function.
        :param V: Potential energy function.
        :param p: Canonical momentum.
        :param q: Canonical coordinate.
    :return: 
        Hamiltonian value H(p, q).
    """
    return T(p, q) + V(q)

def hamiltons_equations_derivative(H, p, q):
    """
    Solve Hamilton's equations for time evolution.
        :param H: Hamiltonian function.
        :param p: Momentum.
        :param q: Coordinate.
    :return: 
        Time derivative of q and p.
    """
    dq_dt = np.gradient(H, p)
    dp_dt = -np.gradient(H, q)
    return dq_dt, dp_dt

def quantization_commutation_relations():
    """
    Define commutation relations for canonical quantization.
    :return: 
        Canonical commutation relations.
    """
    i, hbar = 1j, 1.0545718e-34 # Reduced Planck constant

    def commutator(q, p):
        return i**np.eye(len(q)) # Simplified for illustration
    return commutator 

def schrodinger_equation(H_operator, psi, t):
    """
    Implement the Schrodinger equation for quantum state evolution.
        :param H_operator: Quantum Hamiltonian operator.
        :param psi: Quantum state function.
        :param t: Time variable.
    :return: 
        Time-evolved quantum state.
    """
    hbar = 1.0545718e-34 # Reduced Planck constant
    # Representing exp (-iHt/) for time evolution
    U = expm(-1j * H_operator * t / hbar)
    return U @ psi

def path_integral_action(S, m, V, q, t0, t1):
    """
    Compute the action for a given path, part of path integral
    formulat ion.
    :param S: Action function.
    :param m: Mass.
    :param V: Potential energy.
    :param q: Path.
    :param t0: Initial time.
    :param t1: Final time.
    :return: 
        Action computed over a path.
    """
    dt = t1 - t0
    kinetic_term = 0.5 * m * (np.gradient(q, dt))**2
    action = trapezoid(kinetic_term - V(q), dx=dt)
    return action

def ordering_ambiguities(operators):
    """
    Handle operator ordering ambiguities using symmetrization.
        :param operators: Non-commuting operators.
    :return: 
        Symmetrized operator.
    """
    return 0.5 * (operators["p"] @ operators["q"] + operators["q"] @ operators ["p"] ) 

# Defining example functions T, V, and quantum states
T = lambda p, q: p**2 / (2*1.0) # Assuming mass m = 1
V = lambda q: 0.5 * q**2 # Harmonic potential
p, q = np.array([1.0, 0.5]), np. array( [1.0, 0.5]) # Example momentum and position

# Classical Hamiltonian calculation
H_classical = classical_hamiltonian(T, V, p, q)
# Hamilton's equation derivative
dq_dt, dp_dt = hamiltons_equations_derivative(H_classical, p, q)
# Quantum mechanical components and time evolution
commutation = quantization_commutation_relations()
psi_initial = np.array( [1.0, 0.0]) # Initial quantum state
H_operator = np.diag([0.5, 1.0]) ## Hypothetical Hamiltonian operator
psi_evolved = schrodinger_equation(H_operator, psi_initial, 0.1)
# Example path integral calculation
m, V = 1.0, V # Mass
q_path = np. array( [1.0, 0.5, 0.0]) # Example path
action = path_integral_action(lambda q: T(0, q) - V(q), m, V, q_path, 0.0, 1.0)
# Address operator ordering
operators = {"p": np.array([[0, -1j], [1j, 0]]), "q": np.array([[0, 1], [1, 0]])}
symmetrized_operator = ordering_ambiguities(operators)

print("Classical Hamiltonian:", H_classical)
print("Time Derivatives (dq/dt, dp/dt):", dq_dt, dp_dt)
print("Quantum State Evolution (Schrodinger):", psi_evolved)
print("Path Integral Action:", action)
print("Symmetrized Operator:", symmetrized_operator)

Classical Hamiltonian: [1.   0.25]
Time Derivatives (dq/dt, dp/dt): [1.5 1.5] [-1.5 -1.5]
Quantum State Evolution (Schrodinger): [-0.52525873-0.85094258j  0.        +0.j        ]
Path Integral Action: -0.175
Symmetrized Operator: [[0.+0.j 0.+0.j]
 [0.+0.j 0.+0.j]]
In [19]:
import numpy as np
import matplotlib.pyplot as plt
from scipy.linalg import expm
from scipy.integrate import trapezoid

# Reuse key parts of the provided code to generate insight

# Classical Hamiltonian example
T = lambda p, q: p**2 / 2.0
V = lambda q: 0.5 * q**2
p = np.array([1.0, 0.5])
q = np.array([1.0, 0.5])

H_classical = T(p, q) + V(q)

# Quantum evolution
psi_initial = np.array([1.0, 0.0])
H_operator = np.diag([0.5, 1.0])
t = 0.1
hbar = 1.0545718e-34
psi_evolved = expm(-1j * H_operator * t / hbar) @ psi_initial

# Path integral action
q_path = np.array([1.0, 0.5, 0.0])
m = 1.0
t0, t1 = 0.0, 1.0
dt = t1 - t0
kinetic_term = 0.5 * m * (np.gradient(q_path, dt))**2
action = trapezoid(kinetic_term - V(q_path), dx=dt)

# --- PRINTS ---
print("=== Classical Mechanics ===")
print("p =", p)
print("q =", q)
print("Hamiltonian H(p,q) =", H_classical)

print("\n=== Quantum Mechanics ===")
print("Initial state psi(0) =", psi_initial)
print("Evolved state psi(t) =", psi_evolved)
print("Probability amplitudes |psi(t)|^2 =", np.abs(psi_evolved)**2)

print("\n=== Path Integral ===")
print("q(t) path =", q_path)
print("Kinetic term =", kinetic_term)
print("Action S[q] =", action)

# --- GRAPHICS ---
plt.figure()
plt.plot(q_path, marker='o')
plt.xlabel("Discrete time index")
plt.ylabel("q(t)")
plt.title("Example Path q(t) used in Path Integral")
plt.show()

=== Classical Mechanics ===
p = [1.  0.5]
q = [1.  0.5]
Hamiltonian H(p,q) = [1.   0.25]

=== Quantum Mechanics ===
Initial state psi(0) = [1. 0.]
Evolved state psi(t) = [-0.52525873-0.85094258j  0.        +0.j        ]
Probability amplitudes |psi(t)|^2 = [1. 0.]

=== Path Integral ===
q(t) path = [1.  0.5 0. ]
Kinetic term = [0.125 0.125 0.125]
Action S[q] = -0.125
No description has been provided for this image
In [ ]: